Coverage for manila/tests/share/drivers/dell_emc/plugins/powermax/test_object

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

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

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.

16import copy

17from unittest import mock

19import ddt

20from lxml import builder

21from oslo_concurrency import processutils

23from manila import exception

25from manila.common import constants as const

26from manila.share.drivers.dell_emc.common.enas import connector

27from manila.share.drivers.dell_emc.common.enas import constants

28from manila.share.drivers.dell_emc.common.enas import xml_api_parser as parser

29from manila.share.drivers.dell_emc.plugins.powermax import (

30 object_manager as manager)

31from manila import test

32from manila.tests.share.drivers.dell_emc.common.enas import fakes

33from manila.tests.share.drivers.dell_emc.common.enas import utils

36class StorageObjectManagerTestCase(test.TestCase):

37 @mock.patch.object(connector, "XMLAPIConnector", mock.Mock())

38 @mock.patch.object(connector, "SSHConnector", mock.Mock())

39 def setUp(self):

40 super(StorageObjectManagerTestCase, self).setUp()

42 emd_share_driver = fakes.FakeEMCShareDriver('powermax')

44 self.manager = manager.StorageObjectManager(

45 emd_share_driver.configuration)

47 def test_get_storage_context(self):

48 type_map = {

49 'FileSystem': manager.FileSystem,

50 'StoragePool': manager.StoragePool,

51 'MountPoint': manager.MountPoint,

52 'Mover': manager.Mover,

53 'VDM': manager.VDM,

54 'Snapshot': manager.Snapshot,

55 'MoverInterface': manager.MoverInterface,

56 'DNSDomain': manager.DNSDomain,

57 'CIFSServer': manager.CIFSServer,

58 'CIFSShare': manager.CIFSShare,

59 'NFSShare': manager.NFSShare,

60 }

62 for key, value in type_map.items():

63 self.assertTrue(

64 isinstance(self.manager.getStorageContext(key), value))

66 for key in self.manager.context.keys():

67 self.assertIn(key, type_map)

69 def test_get_storage_context_invalid_type(self):

71 fake_type = 'fake_type'

73 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

74 self.manager.getStorageContext,

75 fake_type)

78class StorageObjectTestCaseBase(test.TestCase):

79 @mock.patch.object(connector, "XMLAPIConnector", mock.Mock())

80 @mock.patch.object(connector, "SSHConnector", mock.Mock())

81 def setUp(self):

82 super(StorageObjectTestCaseBase, self).setUp()

84 emd_share_driver = fakes.FakeEMCShareDriver('powermax')

86 self.manager = manager.StorageObjectManager(

87 emd_share_driver.configuration)

88 self.base = fakes.StorageObjectTestData()

89 self.pool = fakes.PoolTestData()

90 self.vdm = fakes.VDMTestData()

91 self.mover = fakes.MoverTestData()

92 self.fs = fakes.FileSystemTestData()

93 self.mount = fakes.MountPointTestData()

94 self.snap = fakes.SnapshotTestData()

95 self.cifs_share = fakes.CIFSShareTestData()

96 self.nfs_share = fakes.NFSShareTestData()

97 self.cifs_server = fakes.CIFSServerTestData()

98 self.dns = fakes.DNSDomainTestData()

100

101class StorageObjectTestCase(StorageObjectTestCaseBase):

102 def test_xml_api_retry(self):

103 hook = utils.RequestSideEffect()

104 hook.append(self.base.resp_need_retry())

105 hook.append(self.base.resp_task_succeed())

106 elt_maker = builder.ElementMaker(nsmap={None: constants.XML_NAMESPACE})

107 xml_parser = parser.XMLAPIParser()

108 storage_object = manager.StorageObject(self.manager.connectors,

109 elt_maker, xml_parser,

110 self.manager)

111 storage_object.conn['XML'].request = utils.EMCMock(side_effect=hook)

112 fake_req = storage_object._build_task_package(

113 elt_maker.StartFake(name='foo')

114 )

115 resp = storage_object._send_request(fake_req)

116 self.assertEqual('ok', resp['maxSeverity'])

117

118 expected_calls = [

119 mock.call(self.base.req_fake_start_task()),

120 mock.call(self.base.req_fake_start_task())

121 ]

122 storage_object.conn['XML'].request.assert_has_calls(expected_calls)

123

124

125class FileSystemTestCase(StorageObjectTestCaseBase):

126 def setUp(self):

127 super(FileSystemTestCase, self).setUp()

128 self.hook = utils.RequestSideEffect()

129 self.ssh_hook = utils.SSHSideEffect()

130

131 def test_create_file_system_on_vdm(self):

132 self.hook.append(self.pool.resp_get_succeed())

133 self.hook.append(self.vdm.resp_get_succeed())

134 self.hook.append(self.fs.resp_task_succeed())

135

136 context = self.manager.getStorageContext('FileSystem')

137 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

138

139 context.create(name=self.fs.filesystem_name,

140 size=self.fs.filesystem_size,

141 pool_name=self.pool.pool_name,

142 mover_name=self.vdm.vdm_name,

143 is_vdm=True)

144

145 expected_calls = [

146 mock.call(self.pool.req_get()),

147 mock.call(self.vdm.req_get()),

148 mock.call(self.fs.req_create_on_vdm()),

149 ]

150 context.conn['XML'].request.assert_has_calls(expected_calls)

151

152 def test_create_file_system_on_mover(self):

153 self.hook.append(self.pool.resp_get_succeed())

154 self.hook.append(self.mover.resp_get_ref_succeed())

155 self.hook.append(self.fs.resp_task_succeed())

156

157 context = self.manager.getStorageContext('FileSystem')

158 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

159

160 context.create(name=self.fs.filesystem_name,

161 size=self.fs.filesystem_size,

162 pool_name=self.pool.pool_name,

163 mover_name=self.mover.mover_name,

164 is_vdm=False)

165

166 expected_calls = [

167 mock.call(self.pool.req_get()),

168 mock.call(self.mover.req_get_ref()),

169 mock.call(self.fs.req_create_on_mover()),

170 ]

171 context.conn['XML'].request.assert_has_calls(expected_calls)

172

173 def test_create_file_system_but_already_exist(self):

174 self.hook.append(self.pool.resp_get_succeed())

175 self.hook.append(self.vdm.resp_get_succeed())

176 self.hook.append(self.fs.resp_create_but_already_exist())

177

178 context = self.manager.getStorageContext('FileSystem')

179 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

180

181 context.create(name=self.fs.filesystem_name,

182 size=self.fs.filesystem_size,

183 pool_name=self.pool.pool_name,

184 mover_name=self.vdm.vdm_name,

185 is_vdm=True)

186

187 expected_calls = [

188 mock.call(self.pool.req_get()),

189 mock.call(self.vdm.req_get()),

190 mock.call(self.fs.req_create_on_vdm()),

191 ]

192 context.conn['XML'].request.assert_has_calls(expected_calls)

193

194 @mock.patch('time.sleep')

195 def test_create_file_system_invalid_mover_id(self, sleep_mock):

196 self.hook.append(self.pool.resp_get_succeed())

197 self.hook.append(self.mover.resp_get_ref_succeed())

198 self.hook.append(self.fs.resp_invalid_mover_id())

199 self.hook.append(self.mover.resp_get_ref_succeed())

200 self.hook.append(self.fs.resp_task_succeed())

201

202 context = self.manager.getStorageContext('FileSystem')

203 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

204

205 context.create(name=self.fs.filesystem_name,

206 size=self.fs.filesystem_size,

207 pool_name=self.pool.pool_name,

208 mover_name=self.mover.mover_name,

209 is_vdm=False)

210

211 expected_calls = [

212 mock.call(self.pool.req_get()),

213 mock.call(self.mover.req_get_ref()),

214 mock.call(self.fs.req_create_on_mover()),

215 mock.call(self.mover.req_get_ref()),

216 mock.call(self.fs.req_create_on_mover()),

217 ]

218 context.conn['XML'].request.assert_has_calls(expected_calls)

219

220 self.assertTrue(sleep_mock.called)

221

222 def test_create_file_system_with_error(self):

223 self.hook.append(self.pool.resp_get_succeed())

224 self.hook.append(self.vdm.resp_get_succeed())

225 self.hook.append(self.fs.resp_task_error())

226

227 context = self.manager.getStorageContext('FileSystem')

228 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

229

230 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

231 context.create,

232 name=self.fs.filesystem_name,

233 size=self.fs.filesystem_size,

234 pool_name=self.pool.pool_name,

235 mover_name=self.vdm.vdm_name,

236 is_vdm=True)

237

238 expected_calls = [

239 mock.call(self.pool.req_get()),

240 mock.call(self.vdm.req_get()),

241 mock.call(self.fs.req_create_on_vdm()),

242 ]

243 context.conn['XML'].request.assert_has_calls(expected_calls)

244

245 def test_get_file_system(self):

246 self.hook.append(self.fs.resp_get_succeed())

247

248 context = self.manager.getStorageContext('FileSystem')

249 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

250

251 status, out = context.get(self.fs.filesystem_name)

252 self.assertEqual(constants.STATUS_OK, status)

253 self.assertIn(self.fs.filesystem_name, context.filesystem_map)

254 property_map = [

255 'name',

256 'pools_id',

257 'volume_id',

258 'size',

259 'id',

260 'type',

261 'dataServicePolicies',

262 ]

263 for prop in property_map:

264 self.assertIn(prop, out)

265

266 id = context.get_id(self.fs.filesystem_name)

267 self.assertEqual(self.fs.filesystem_id, id)

268

269 expected_calls = [mock.call(self.fs.req_get())]

270 context.conn['XML'].request.assert_has_calls(expected_calls)

271

272 def test_get_file_system_but_not_found(self):

273 self.hook.append(self.fs.resp_get_but_not_found())

274 self.hook.append(self.fs.resp_get_without_value())

275 self.hook.append(self.fs.resp_get_error())

276 self.hook.append(self.fs.resp_get_but_not_found())

277

278 context = self.manager.getStorageContext('FileSystem')

279 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

280

281 status, out = context.get(self.fs.filesystem_name)

282 self.assertEqual(constants.STATUS_NOT_FOUND, status)

283

284 status, out = context.get(self.fs.filesystem_name)

285 self.assertEqual(constants.STATUS_NOT_FOUND, status)

286

287 status, out = context.get(self.fs.filesystem_name)

288 self.assertEqual(constants.STATUS_ERROR, status)

289

290 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

291 context.get_id,

292 self.fs.filesystem_name)

293

294 expected_calls = [

295 mock.call(self.fs.req_get()),

296 mock.call(self.fs.req_get()),

297 mock.call(self.fs.req_get()),

298 mock.call(self.fs.req_get()),

299 ]

300 context.conn['XML'].request.assert_has_calls(expected_calls)

301

302 def test_get_file_system_but_miss_property(self):

303 self.hook.append(self.fs.resp_get_but_miss_property())

304

305 context = self.manager.getStorageContext('FileSystem')

306 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

307

308 status, out = context.get(self.fs.filesystem_name)

309 self.assertEqual(constants.STATUS_OK, status)

310 self.assertIn(self.fs.filesystem_name, context.filesystem_map)

311 property_map = [

312 'name',

313 'pools_id',

314 'volume_id',

315 'size',

316 'id',

317 'type',

318 'dataServicePolicies',

319 ]

320 for prop in property_map:

321 self.assertIn(prop, out)

322

323 self.assertIsNone(out['dataServicePolicies'])

324

325 id = context.get_id(self.fs.filesystem_name)

326 self.assertEqual(self.fs.filesystem_id, id)

327

328 expected_calls = [mock.call(self.fs.req_get())]

329 context.conn['XML'].request.assert_has_calls(expected_calls)

330

331 def test_delete_file_system(self):

332 self.hook.append(self.fs.resp_get_succeed())

333 self.hook.append(self.fs.resp_task_succeed())

334

335 context = self.manager.getStorageContext('FileSystem')

336 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

337

338 context.delete(self.fs.filesystem_name)

339 self.assertNotIn(self.fs.filesystem_name, context.filesystem_map)

340

341 expected_calls = [

342 mock.call(self.fs.req_get()),

343 mock.call(self.fs.req_delete()),

344 ]

345 context.conn['XML'].request.assert_has_calls(expected_calls)

346

347 self.assertNotIn(self.fs.filesystem_name, context.filesystem_map)

348

349 def test_delete_file_system_but_not_found(self):

350 self.hook.append(self.fs.resp_get_but_not_found())

351

352 context = self.manager.getStorageContext('FileSystem')

353 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

354

355 context.delete(self.fs.filesystem_name)

356

357 expected_calls = [mock.call(self.fs.req_get())]

358 context.conn['XML'].request.assert_has_calls(expected_calls)

359

360 def test_delete_file_system_but_get_file_system_error(self):

361 self.hook.append(self.fs.resp_get_error())

362

363 context = self.manager.getStorageContext('FileSystem')

364 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

365

366 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

367 context.delete,

368 self.fs.filesystem_name)

369

370 expected_calls = [mock.call(self.fs.req_get())]

371 context.conn['XML'].request.assert_has_calls(expected_calls)

372

373 def test_delete_file_system_with_error(self):

374 self.hook.append(self.fs.resp_get_succeed())

375 self.hook.append(self.fs.resp_delete_but_failed())

376

377 context = self.manager.getStorageContext('FileSystem')

378 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

379

380 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

381 context.delete,

382 self.fs.filesystem_name)

383

384 expected_calls = [

385 mock.call(self.fs.req_get()),

386 mock.call(self.fs.req_delete()),

387 ]

388 context.conn['XML'].request.assert_has_calls(expected_calls)

389

390 self.assertIn(self.fs.filesystem_name, context.filesystem_map)

391

392 def test_extend_file_system(self):

393 self.hook.append(self.fs.resp_get_succeed())

394 self.hook.append(self.pool.resp_get_succeed())

395 self.hook.append(self.fs.resp_task_succeed())

396

397 context = self.manager.getStorageContext('FileSystem')

398 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

399

400 context.extend(name=self.fs.filesystem_name,

401 pool_name=self.pool.pool_name,

402 new_size=self.fs.filesystem_new_size)

403

404 expected_calls = [

405 mock.call(self.fs.req_get()),

406 mock.call(self.pool.req_get()),

407 mock.call(self.fs.req_extend()),

408 ]

409 context.conn['XML'].request.assert_has_calls(expected_calls)

410

411 def test_extend_file_system_but_not_found(self):

412 self.hook.append(self.fs.resp_get_but_not_found())

413

414 context = self.manager.getStorageContext('FileSystem')

415 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

416

417 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

418 context.extend,

419 name=self.fs.filesystem_name,

420 pool_name=self.fs.pool_name,

421 new_size=self.fs.filesystem_new_size)

422

423 expected_calls = [mock.call(self.fs.req_get())]

424 context.conn['XML'].request.assert_has_calls(expected_calls)

425

426 def test_extend_file_system_with_small_size(self):

427 self.hook.append(self.fs.resp_get_succeed())

428

429 context = self.manager.getStorageContext('FileSystem')

430 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

431

432 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

433 context.extend,

434 name=self.fs.filesystem_name,

435 pool_name=self.pool.pool_name,

436 new_size=1)

437

438 expected_calls = [mock.call(self.fs.req_get())]

439 context.conn['XML'].request.assert_has_calls(expected_calls)

440

441 def test_extend_file_system_with_same_size(self):

442 self.hook.append(self.fs.resp_get_succeed())

443

444 context = self.manager.getStorageContext('FileSystem')

445 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

446

447 context.extend(name=self.fs.filesystem_name,

448 pool_name=self.pool.pool_name,

449 new_size=self.fs.filesystem_size)

450

451 expected_calls = [mock.call(self.fs.req_get())]

452 context.conn['XML'].request.assert_has_calls(expected_calls)

453

454 def test_extend_file_system_with_error(self):

455 self.hook.append(self.fs.resp_get_succeed())

456 self.hook.append(self.pool.resp_get_succeed())

457 self.hook.append(self.fs.resp_extend_but_error())

458

459 context = self.manager.getStorageContext('FileSystem')

460 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

461

462 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

463 context.extend,

464 name=self.fs.filesystem_name,

465 pool_name=self.pool.pool_name,

466 new_size=self.fs.filesystem_new_size)

467

468 expected_calls = [

469 mock.call(self.fs.req_get()),

470 mock.call(self.pool.req_get()),

471 mock.call(self.fs.req_extend()),

472 ]

473 context.conn['XML'].request.assert_has_calls(expected_calls)

474

475 def test_create_filesystem_from_snapshot(self):

476 self.ssh_hook.append()

477 self.ssh_hook.append()

478 self.ssh_hook.append(self.fs.output_copy_ckpt)

479 self.ssh_hook.append(self.fs.output_info())

480 self.ssh_hook.append()

481 self.ssh_hook.append()

482 self.ssh_hook.append()

483

484 context = self.manager.getStorageContext('FileSystem')

485 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

486

487 context.create_from_snapshot(self.fs.filesystem_name,

488 self.snap.src_snap_name,

489 self.fs.src_fileystems_name,

490 self.pool.pool_name,

491 self.vdm.vdm_name,

492 self.mover.interconnect_id)

493

494 ssh_calls = [

495 mock.call(self.fs.cmd_create_from_ckpt(), False),

496 mock.call(self.mount.cmd_server_mount('ro'), False),

497 mock.call(self.fs.cmd_copy_ckpt(), True),

498 mock.call(self.fs.cmd_nas_fs_info(), False),

499 mock.call(self.mount.cmd_server_umount(), False),

500 mock.call(self.fs.cmd_delete(), False),

501 mock.call(self.mount.cmd_server_mount('rw'), False),

502 ]

503 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

504

505 def test_create_filesystem_from_snapshot_with_error(self):

506 self.ssh_hook.append()

507 self.ssh_hook.append()

508 self.ssh_hook.append(ex=processutils.ProcessExecutionError(

509 stdout=self.fs.fake_output, stderr=None))

510 self.ssh_hook.append(self.fs.output_info())

511 self.ssh_hook.append()

512 self.ssh_hook.append()

513 self.ssh_hook.append()

514

515 context = self.manager.getStorageContext('FileSystem')

516 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

517

518 context.create_from_snapshot(

519 self.fs.filesystem_name,

520 self.snap.src_snap_name,

521 self.fs.src_fileystems_name,

522 self.pool.pool_name,

523 self.vdm.vdm_name,

524 self.mover.interconnect_id, )

525

526 ssh_calls = [

527 mock.call(self.fs.cmd_create_from_ckpt(), False),

528 mock.call(self.mount.cmd_server_mount('ro'), False),

529 mock.call(self.fs.cmd_copy_ckpt(), True),

530 mock.call(self.fs.cmd_nas_fs_info(), False),

531 mock.call(self.mount.cmd_server_umount(), False),

532 mock.call(self.fs.cmd_delete(), False),

533 mock.call(self.mount.cmd_server_mount('rw'), False),

534 ]

535 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

536

537

538class MountPointTestCase(StorageObjectTestCaseBase):

539 def setUp(self):

540 super(MountPointTestCase, self).setUp()

541 self.hook = utils.RequestSideEffect()

542

543 def test_create_mount_point_on_vdm(self):

544 self.hook.append(self.fs.resp_get_succeed())

545 self.hook.append(self.vdm.resp_get_succeed())

546 self.hook.append(self.mount.resp_task_succeed())

547

548 context = self.manager.getStorageContext('MountPoint')

549 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

550

551 context.create(mount_path=self.mount.path,

552 fs_name=self.fs.filesystem_name,

553 mover_name=self.vdm.vdm_name,

554 is_vdm=True)

555

556 expected_calls = [

557 mock.call(self.fs.req_get()),

558 mock.call(self.vdm.req_get()),

559 mock.call(self.mount.req_create(self.vdm.vdm_id, True)),

560 ]

561 context.conn['XML'].request.assert_has_calls(expected_calls)

562

563 def test_create_mount_point_on_mover(self):

564 self.hook.append(self.fs.resp_get_succeed())

565 self.hook.append(self.mover.resp_get_ref_succeed())

566 self.hook.append(self.mount.resp_task_succeed())

567

568 context = self.manager.getStorageContext('MountPoint')

569 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

570

571 context.create(mount_path=self.mount.path,

572 fs_name=self.fs.filesystem_name,

573 mover_name=self.mover.mover_name,

574 is_vdm=False)

575

576 expected_calls = [

577 mock.call(self.fs.req_get()),

578 mock.call(self.mover.req_get_ref()),

579 mock.call(self.mount.req_create(self.mover.mover_id, False)),

580 ]

581 context.conn['XML'].request.assert_has_calls(expected_calls)

582

583 def test_create_mount_point_but_already_exist(self):

584 self.hook.append(self.fs.resp_get_succeed())

585 self.hook.append(self.vdm.resp_get_succeed())

586 self.hook.append(self.mount.resp_create_but_already_exist())

587

588 context = self.manager.getStorageContext('MountPoint')

589 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

590

591 context.create(mount_path=self.mount.path,

592 fs_name=self.fs.filesystem_name,

593 mover_name=self.vdm.vdm_name,

594 is_vdm=True)

595

596 expected_calls = [

597 mock.call(self.fs.req_get()),

598 mock.call(self.vdm.req_get()),

599 mock.call(self.mount.req_create(self.vdm.vdm_id)),

600 ]

601 context.conn['XML'].request.assert_has_calls(expected_calls)

602

603 @mock.patch('time.sleep')

604 def test_create_mount_point_invalid_mover_id(self, sleep_mock):

605 self.hook.append(self.fs.resp_get_succeed())

606 self.hook.append(self.mover.resp_get_ref_succeed())

607 self.hook.append(self.mount.resp_invalid_mover_id())

608 self.hook.append(self.mover.resp_get_ref_succeed())

609 self.hook.append(self.mount.resp_task_succeed())

610

611 context = self.manager.getStorageContext('MountPoint')

612 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

613

614 context.create(mount_path=self.mount.path,

615 fs_name=self.fs.filesystem_name,

616 mover_name=self.mover.mover_name,

617 is_vdm=False)

618

619 expected_calls = [

620 mock.call(self.fs.req_get()),

621 mock.call(self.mover.req_get_ref()),

622 mock.call(self.mount.req_create(self.mover.mover_id, False)),

623 mock.call(self.mover.req_get_ref()),

624 mock.call(self.mount.req_create(self.mover.mover_id, False)),

625 ]

626 context.conn['XML'].request.assert_has_calls(expected_calls)

627

628 self.assertTrue(sleep_mock.called)

629

630 def test_create_mount_point_with_error(self):

631 self.hook.append(self.fs.resp_get_succeed())

632 self.hook.append(self.vdm.resp_get_succeed())

633 self.hook.append(self.mount.resp_task_error())

634

635 context = self.manager.getStorageContext('MountPoint')

636 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

637

638 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

639 context.create,

640 mount_path=self.mount.path,

641 fs_name=self.fs.filesystem_name,

642 mover_name=self.vdm.vdm_name,

643 is_vdm=True)

644

645 expected_calls = [

646 mock.call(self.fs.req_get()),

647 mock.call(self.vdm.req_get()),

648 mock.call(self.mount.req_create(self.vdm.vdm_id)),

649 ]

650 context.conn['XML'].request.assert_has_calls(expected_calls)

651

652 def test_delete_mount_point_on_vdm(self):

653 self.hook.append(self.vdm.resp_get_succeed())

654 self.hook.append(self.mount.resp_task_succeed())

655

656 context = self.manager.getStorageContext('MountPoint')

657 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

658

659 context.delete(mount_path=self.mount.path,

660 mover_name=self.vdm.vdm_name,

661 is_vdm=True)

662

663 expected_calls = [

664 mock.call(self.vdm.req_get()),

665 mock.call(self.mount.req_delete(self.vdm.vdm_id)),

666 ]

667 context.conn['XML'].request.assert_has_calls(expected_calls)

668

669 def test_delete_mount_point_on_mover(self):

670 self.hook.append(self.mover.resp_get_ref_succeed())

671 self.hook.append(self.mount.resp_task_succeed())

672

673 context = self.manager.getStorageContext('MountPoint')

674 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

675

676 context.delete(mount_path=self.mount.path,

677 mover_name=self.mover.mover_name,

678 is_vdm=False)

679

680 expected_calls = [

681 mock.call(self.mover.req_get_ref()),

682 mock.call(self.mount.req_delete(self.mover.mover_id, False)),

683 ]

684 context.conn['XML'].request.assert_has_calls(expected_calls)

685

686 def test_delete_mount_point_but_nonexistent(self):

687 self.hook.append(self.vdm.resp_get_succeed())

688 self.hook.append(self.mount.resp_delete_but_nonexistent())

689

690 context = self.manager.getStorageContext('MountPoint')

691 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

692

693 context.delete(mount_path=self.mount.path,

694 mover_name=self.vdm.vdm_name,

695 is_vdm=True)

696

697 expected_calls = [

698 mock.call(self.vdm.req_get()),

699 mock.call(self.mount.req_delete(self.vdm.vdm_id)),

700 ]

701 context.conn['XML'].request.assert_has_calls(expected_calls)

702

703 @mock.patch('time.sleep')

704 def test_delete_mount_point_invalid_mover_id(self, sleep_mock):

705 self.hook.append(self.mover.resp_get_ref_succeed())

706 self.hook.append(self.mount.resp_invalid_mover_id())

707 self.hook.append(self.mover.resp_get_ref_succeed())

708 self.hook.append(self.mount.resp_task_succeed())

709

710 context = self.manager.getStorageContext('MountPoint')

711 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

712

713 context.delete(mount_path=self.mount.path,

714 mover_name=self.mover.mover_name,

715 is_vdm=False)

716

717 expected_calls = [

718 mock.call(self.mover.req_get_ref()),

719 mock.call(self.mount.req_delete(self.mover.mover_id, False)),

720 mock.call(self.mover.req_get_ref()),

721 mock.call(self.mount.req_delete(self.mover.mover_id, False)),

722 ]

723 context.conn['XML'].request.assert_has_calls(expected_calls)

724

725 self.assertTrue(sleep_mock.called)

726

727 def test_delete_mount_point_with_error(self):

728 self.hook.append(self.vdm.resp_get_succeed())

729 self.hook.append(self.mount.resp_task_error())

730

731 context = self.manager.getStorageContext('MountPoint')

732 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

733

734 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

735 context.delete,

736 mount_path=self.mount.path,

737 mover_name=self.vdm.vdm_name,

738 is_vdm=True)

739

740 expected_calls = [

741 mock.call(self.vdm.req_get()),

742 mock.call(self.mount.req_delete(self.vdm.vdm_id)),

743 ]

744 context.conn['XML'].request.assert_has_calls(expected_calls)

745

746 def test_get_mount_points(self):

747 self.hook.append(self.vdm.resp_get_succeed())

748 self.hook.append(self.mount.resp_get_succeed(self.vdm.vdm_id))

749 self.hook.append(self.mover.resp_get_ref_succeed())

750 self.hook.append(self.mount.resp_get_succeed(self.mover.mover_id,

751 False))

752

753 context = self.manager.getStorageContext('MountPoint')

754 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

755

756 status, out = context.get(self.vdm.vdm_name)

757 self.assertEqual(constants.STATUS_OK, status)

758 property_map = [

759 'path',

760 'mover',

761 'moverIdIsVdm',

762 'fileSystem',

763 ]

764 for item in out:

765 for prop in property_map:

766 self.assertIn(prop, item)

767

768 status, out = context.get(self.mover.mover_name, False)

769 self.assertEqual(constants.STATUS_OK, status)

770 property_map = [

771 'path',

772 'mover',

773 'moverIdIsVdm',

774 'fileSystem',

775 ]

776 for item in out:

777 for prop in property_map:

778 self.assertIn(prop, item)

779

780 expected_calls = [

781 mock.call(self.vdm.req_get()),

782 mock.call(self.mount.req_get(self.vdm.vdm_id)),

783 mock.call(self.mover.req_get_ref()),

784 mock.call(self.mount.req_get(self.mover.mover_id, False)),

785 ]

786 context.conn['XML'].request.assert_has_calls(expected_calls)

787

788 def test_get_mount_points_but_not_found(self):

789 self.hook.append(self.mover.resp_get_ref_succeed())

790 self.hook.append(self.mount.resp_get_without_value())

791

792 context = self.manager.getStorageContext('MountPoint')

793 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

794

795 status, out = context.get(self.mover.mover_name, False)

796 self.assertEqual(constants.STATUS_NOT_FOUND, status)

797

798 expected_calls = [

799 mock.call(self.mover.req_get_ref()),

800 mock.call(self.mount.req_get(self.mover.mover_id, False)),

801 ]

802 context.conn['XML'].request.assert_has_calls(expected_calls)

803

804 @mock.patch('time.sleep')

805 def test_get_mount_points_invalid_mover_id(self, sleep_mock):

806 self.hook.append(self.mover.resp_get_ref_succeed())

807 self.hook.append(self.mount.resp_invalid_mover_id())

808 self.hook.append(self.mover.resp_get_ref_succeed())

809 self.hook.append(self.mount.resp_get_succeed(self.mover.mover_id,

810 False))

811

812 context = self.manager.getStorageContext('MountPoint')

813 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

814

815 status, out = context.get(self.mover.mover_name, False)

816 self.assertEqual(constants.STATUS_OK, status)

817

818 property_map = [

819 'path',

820 'mover',

821 'moverIdIsVdm',

822 'fileSystem',

823 ]

824 for item in out:

825 for prop in property_map:

826 self.assertIn(prop, item)

827

828 expected_calls = [

829 mock.call(self.mover.req_get_ref()),

830 mock.call(self.mount.req_get(self.mover.mover_id, False)),

831 mock.call(self.mover.req_get_ref()),

832 mock.call(self.mount.req_get(self.mover.mover_id, False)),

833 ]

834 context.conn['XML'].request.assert_has_calls(expected_calls)

835

836 self.assertTrue(sleep_mock.called)

837

838 def test_get_mount_points_with_error(self):

839 self.hook.append(self.mover.resp_get_ref_succeed())

840 self.hook.append(self.mount.resp_get_error())

841

842 context = self.manager.getStorageContext('MountPoint')

843 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

844

845 status, out = context.get(self.mover.mover_name, False)

846 self.assertEqual(constants.STATUS_ERROR, status)

847

848 expected_calls = [

849 mock.call(self.mover.req_get_ref()),

850 mock.call(self.mount.req_get(self.mover.mover_id, False)),

851 ]

852 context.conn['XML'].request.assert_has_calls(expected_calls)

853

854

855class VDMTestCase(StorageObjectTestCaseBase):

856 def setUp(self):

857 super(VDMTestCase, self).setUp()

858 self.hook = utils.RequestSideEffect()

859 self.ssh_hook = utils.SSHSideEffect()

860

861 def test_create_vdm(self):

862 self.hook.append(self.mover.resp_get_ref_succeed())

863 self.hook.append(self.vdm.resp_task_succeed())

864

865 context = self.manager.getStorageContext('VDM')

866 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

867

868 context.create(self.vdm.vdm_name, self.mover.mover_name)

869

870 expected_calls = [

871 mock.call(self.mover.req_get_ref()),

872 mock.call(self.vdm.req_create()),

873 ]

874 context.conn['XML'].request.assert_has_calls(expected_calls)

875

876 def test_create_vdm_but_already_exist(self):

877 self.hook.append(self.mover.resp_get_ref_succeed())

878 self.hook.append(self.vdm.resp_create_but_already_exist())

879

880 context = self.manager.getStorageContext('VDM')

881 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

882

883 # Create VDM which already exists.

884 context.create(self.vdm.vdm_name, self.mover.mover_name)

885

886 expected_calls = [

887 mock.call(self.mover.req_get_ref()),

888 mock.call(self.vdm.req_create()),

889 ]

890 context.conn['XML'].request.assert_has_calls(expected_calls)

891

892 @mock.patch('time.sleep')

893 def test_create_vdm_invalid_mover_id(self, sleep_mock):

894 self.hook.append(self.mover.resp_get_ref_succeed())

895 self.hook.append(self.vdm.resp_invalid_mover_id())

896 self.hook.append(self.mover.resp_get_ref_succeed())

897 self.hook.append(self.vdm.resp_task_succeed())

898

899 context = self.manager.getStorageContext('VDM')

900 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

901

902 # Create VDM with invalid mover ID

903 context.create(self.vdm.vdm_name, self.mover.mover_name)

904

905 expected_calls = [

906 mock.call(self.mover.req_get_ref()),

907 mock.call(self.vdm.req_create()),

908 mock.call(self.mover.req_get_ref()),

909 mock.call(self.vdm.req_create()),

910 ]

911 context.conn['XML'].request.assert_has_calls(expected_calls)

912

913 self.assertTrue(sleep_mock.called)

914

915 def test_create_vdm_with_error(self):

916 self.hook.append(self.mover.resp_get_ref_succeed())

917 self.hook.append(self.vdm.resp_task_error())

918

919 context = self.manager.getStorageContext('VDM')

920 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

921

922 # Create VDM with invalid mover ID

923 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

924 context.create,

925 name=self.vdm.vdm_name,

926 mover_name=self.mover.mover_name)

927

928 expected_calls = [

929 mock.call(self.mover.req_get_ref()),

930 mock.call(self.vdm.req_create()),

931 ]

932 context.conn['XML'].request.assert_has_calls(expected_calls)

933

934 def test_get_vdm(self):

935 self.hook.append(self.vdm.resp_get_succeed())

936

937 context = self.manager.getStorageContext('VDM')

938 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

939

940 status, out = context.get(self.vdm.vdm_name)

941 self.assertEqual(constants.STATUS_OK, status)

942 self.assertIn(self.vdm.vdm_name, context.vdm_map)

943 property_map = [

944 'name',

945 'id',

946 'state',

947 'host_mover_id',

948 'interfaces',

949 ]

950 for prop in property_map:

951 self.assertIn(prop, out)

952

953 expected_calls = [mock.call(self.vdm.req_get())]

954 context.conn['XML'].request.assert_has_calls(expected_calls)

955

956 def test_get_vdm_with_error(self):

957 self.hook.append(self.vdm.resp_get_error())

958

959 context = self.manager.getStorageContext('VDM')

960 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

961

962 # Get VDM with error

963 status, out = context.get(self.vdm.vdm_name)

964 self.assertEqual(constants.STATUS_ERROR, status)

965

966 expected_calls = [mock.call(self.vdm.req_get())]

967 context.conn['XML'].request.assert_has_calls(expected_calls)

968

969 def test_get_vdm_but_not_found(self):

970 self.hook.append(self.vdm.resp_get_without_value())

971 self.hook.append(self.vdm.resp_get_succeed('fake'))

972

973 context = self.manager.getStorageContext('VDM')

974 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

975

976 # Get VDM which does not exist

977 status, out = context.get(self.vdm.vdm_name)

978 self.assertEqual(constants.STATUS_NOT_FOUND, status)

979

980 status, out = context.get(self.vdm.vdm_name)

981 self.assertEqual(constants.STATUS_NOT_FOUND, status)

982

983 expected_calls = [

984 mock.call(self.vdm.req_get()),

985 mock.call(self.vdm.req_get()),

986 ]

987 context.conn['XML'].request.assert_has_calls(expected_calls)

988

989 def test_get_vdm_id_with_error(self):

990 self.hook.append(self.vdm.resp_get_error())

991

992 context = self.manager.getStorageContext('VDM')

993 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

994

995 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

996 context.get_id,

997 self.vdm.vdm_name)

998

999 expected_calls = [mock.call(self.vdm.req_get())]

1000 context.conn['XML'].request.assert_has_calls(expected_calls)

1001

1002 def test_delete_vdm(self):

1003 self.hook.append(self.vdm.resp_get_succeed())

1004 self.hook.append(self.vdm.resp_task_succeed())

1005

1006 context = self.manager.getStorageContext('VDM')

1007 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1008

1009 context.delete(self.vdm.vdm_name)

1010

1011 expected_calls = [

1012 mock.call(self.vdm.req_get()),

1013 mock.call(self.vdm.req_delete()),

1014 ]

1015 context.conn['XML'].request.assert_has_calls(expected_calls)

1016

1017 def test_delete_vdm_but_not_found(self):

1018 self.hook.append(self.vdm.resp_get_but_not_found())

1019

1020 context = self.manager.getStorageContext('VDM')

1021 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1022

1023 context.delete(self.vdm.vdm_name)

1024

1025 expected_calls = [mock.call(self.vdm.req_get())]

1026 context.conn['XML'].request.assert_has_calls(expected_calls)

1027

1028 def test_delete_vdm_but_failed_to_get_vdm(self):

1029 self.hook.append(self.vdm.resp_get_error())

1030

1031 context = self.manager.getStorageContext('VDM')

1032 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1033

1034 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

1035 context.delete,

1036 self.vdm.vdm_name)

1037

1038 expected_calls = [mock.call(self.vdm.req_get())]

1039 context.conn['XML'].request.assert_has_calls(expected_calls)

1040

1041 def test_delete_vdm_with_error(self):

1042 self.hook.append(self.vdm.resp_get_succeed())

1043 self.hook.append(self.vdm.resp_task_error())

1044

1045 context = self.manager.getStorageContext('VDM')

1046 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1047

1048 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

1049 context.delete,

1050 self.vdm.vdm_name)

1051

1052 expected_calls = [

1053 mock.call(self.vdm.req_get()),

1054 mock.call(self.vdm.req_delete()),

1055 ]

1056 context.conn['XML'].request.assert_has_calls(expected_calls)

1057

1058 def test_attach_detach_nfs_interface(self):

1059 self.ssh_hook.append()

1060 self.ssh_hook.append()

1061

1062 context = self.manager.getStorageContext('VDM')

1063 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

1064

1065 context.attach_nfs_interface(self.vdm.vdm_name,

1066 self.mover.interface_name2)

1067 context.detach_nfs_interface(self.vdm.vdm_name,

1068 self.mover.interface_name2)

1069

1070 ssh_calls = [

1071 mock.call(self.vdm.cmd_attach_nfs_interface(), False),

1072 mock.call(self.vdm.cmd_detach_nfs_interface(), True),

1073 ]

1074 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

1075

1076 def test_detach_nfs_interface_with_error(self):

1077 self.ssh_hook.append(ex=processutils.ProcessExecutionError(

1078 stdout=self.vdm.fake_output))

1079 self.ssh_hook.append(self.vdm.output_get_interfaces_vdm(

1080 self.mover.interface_name2))

1081 self.ssh_hook.append(ex=processutils.ProcessExecutionError(

1082 stdout=self.vdm.fake_output))

1083 self.ssh_hook.append(self.vdm.output_get_interfaces_vdm(

1084 nfs_interface=fakes.FakeData.interface_name1))

1085

1086 context = self.manager.getStorageContext('VDM')

1087 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

1088

1089 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

1090 context.detach_nfs_interface,

1091 self.vdm.vdm_name,

1092 self.mover.interface_name2)

1093

1094 context.detach_nfs_interface(self.vdm.vdm_name,

1095 self.mover.interface_name2)

1096

1097 ssh_calls = [

1098 mock.call(self.vdm.cmd_detach_nfs_interface(), True),

1099 mock.call(self.vdm.cmd_get_interfaces(), False),

1100 mock.call(self.vdm.cmd_detach_nfs_interface(), True),

1101 mock.call(self.vdm.cmd_get_interfaces(), False),

1102 ]

1103 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

1104

1105 def test_get_cifs_nfs_interface(self):

1106 self.ssh_hook.append(self.vdm.output_get_interfaces_vdm())

1107

1108 context = self.manager.getStorageContext('VDM')

1109 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

1110

1111 interfaces = context.get_interfaces(self.vdm.vdm_name)

1112 self.assertIsNotNone(interfaces['cifs'])

1113 self.assertIsNotNone(interfaces['nfs'])

1114

1115 ssh_calls = [mock.call(self.vdm.cmd_get_interfaces(), False)]

1116 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

1117

1118

1119class StoragePoolTestCase(StorageObjectTestCaseBase):

1120 def setUp(self):

1121 super(StoragePoolTestCase, self).setUp()

1122 self.hook = utils.RequestSideEffect()

1123

1124 def test_get_pool(self):

1125 self.hook.append(self.pool.resp_get_succeed())

1126

1127 context = self.manager.getStorageContext('StoragePool')

1128 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1129

1130 status, out = context.get(self.pool.pool_name)

1131 self.assertEqual(constants.STATUS_OK, status)

1132 self.assertIn(self.pool.pool_name, context.pool_map)

1133 property_map = [

1134 'name',

1135 'movers_id',

1136 'total_size',

1137 'used_size',

1138 'diskType',

1139 'dataServicePolicies',

1140 'id',

1141 ]

1142 for prop in property_map:

1143 self.assertIn(prop, out)

1144

1145 expected_calls = [mock.call(self.pool.req_get())]

1146 context.conn['XML'].request.assert_has_calls(expected_calls)

1147

1148 def test_get_pool_with_error(self):

1149 self.hook.append(self.pool.resp_get_error())

1150 self.hook.append(self.pool.resp_get_without_value())

1151 self.hook.append(self.pool.resp_get_succeed(name='other'))

1152

1153 context = self.manager.getStorageContext('StoragePool')

1154 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1155

1156 status, out = context.get(self.pool.pool_name)

1157 self.assertEqual(constants.STATUS_ERROR, status)

1158

1159 status, out = context.get(self.pool.pool_name)

1160 self.assertEqual(constants.STATUS_NOT_FOUND, status)

1161

1162 status, out = context.get(self.pool.pool_name)

1163 self.assertEqual(constants.STATUS_NOT_FOUND, status)

1164

1165 expected_calls = [

1166 mock.call(self.pool.req_get()),

1167 mock.call(self.pool.req_get()),

1168 mock.call(self.pool.req_get()),

1169 ]

1170 context.conn['XML'].request.assert_has_calls(expected_calls)

1171

1172 def test_get_pool_id_with_error(self):

1173 self.hook.append(self.pool.resp_get_error())

1174

1175 context = self.manager.getStorageContext('StoragePool')

1176 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1177

1178 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

1179 context.get_id,

1180 self.pool.pool_name)

1181

1182 expected_calls = [mock.call(self.pool.req_get())]

1183 context.conn['XML'].request.assert_has_calls(expected_calls)

1184

1185

1186class MoverTestCase(StorageObjectTestCaseBase):

1187 def setUp(self):

1188 super(MoverTestCase, self).setUp()

1189 self.hook = utils.RequestSideEffect()

1190 self.ssh_hook = utils.SSHSideEffect()

1191

1192 def test_get_mover(self):

1193 self.hook.append(self.mover.resp_get_ref_succeed())

1194 self.hook.append(self.mover.resp_get_succeed())

1195 self.hook.append(self.mover.resp_get_ref_succeed())

1196 self.hook.append(self.mover.resp_get_succeed())

1197

1198 context = self.manager.getStorageContext('Mover')

1199 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1200

1201 status, out = context.get(self.mover.mover_name)

1202 self.assertEqual(constants.STATUS_OK, status)

1203 self.assertIn(self.mover.mover_name, context.mover_map)

1204 property_map = [

1205 'name',

1206 'id',

1207 'Status',

1208 'version',

1209 'uptime',

1210 'role',

1211 'interfaces',

1212 'devices',

1213 'dns_domain',

1214 ]

1215 for prop in property_map:

1216 self.assertIn(prop, out)

1217

1218 status, out = context.get(self.mover.mover_name)

1219 self.assertEqual(constants.STATUS_OK, status)

1220

1221 status, out = context.get(self.mover.mover_name, True)

1222 self.assertEqual(constants.STATUS_OK, status)

1223

1224 expected_calls = [

1225 mock.call(self.mover.req_get_ref()),

1226 mock.call(self.mover.req_get()),

1227 mock.call(self.mover.req_get_ref()),

1228 mock.call(self.mover.req_get()),

1229 ]

1230 context.conn['XML'].request.assert_has_calls(expected_calls)

1231

1232 def test_get_mover_ref_not_found(self):

1233 self.hook.append(self.mover.resp_get_ref_succeed(name='other'))

1234

1235 context = self.manager.getStorageContext('Mover')

1236 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1237

1238 status, out = context.get_ref(self.mover.mover_name)

1239 self.assertEqual(constants.STATUS_NOT_FOUND, status)

1240

1241 expected_calls = [mock.call(self.mover.req_get_ref())]

1242 context.conn['XML'].request.assert_has_calls(expected_calls)

1243

1244 def test_get_mover_ref_with_error(self):

1245 self.hook.append(self.mover.resp_get_error())

1246

1247 context = self.manager.getStorageContext('Mover')

1248 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1249

1250 status, out = context.get_ref(self.mover.mover_name)

1251 self.assertEqual(constants.STATUS_ERROR, status)

1252

1253 expected_calls = [mock.call(self.mover.req_get_ref())]

1254 context.conn['XML'].request.assert_has_calls(expected_calls)

1255

1256 def test_get_mover_ref_and_mover(self):

1257 self.hook.append(self.mover.resp_get_ref_succeed())

1258 self.hook.append(self.mover.resp_get_succeed())

1259

1260 context = self.manager.getStorageContext('Mover')

1261 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1262

1263 status, out = context.get_ref(self.mover.mover_name)

1264 self.assertEqual(constants.STATUS_OK, status)

1265 property_map = ['name', 'id']

1266 for prop in property_map:

1267 self.assertIn(prop, out)

1268

1269 status, out = context.get(self.mover.mover_name)

1270 self.assertEqual(constants.STATUS_OK, status)

1271 self.assertIn(self.mover.mover_name, context.mover_map)

1272 property_map = [

1273 'name',

1274 'id',

1275 'Status',

1276 'version',

1277 'uptime',

1278 'role',

1279 'interfaces',

1280 'devices',

1281 'dns_domain',

1282 ]

1283 for prop in property_map:

1284 self.assertIn(prop, out)

1285

1286 expected_calls = [

1287 mock.call(self.mover.req_get_ref()),

1288 mock.call(self.mover.req_get()),

1289 ]

1290 context.conn['XML'].request.assert_has_calls(expected_calls)

1291

1292 def test_get_mover_failed_to_get_mover_ref(self):

1293 self.hook.append(self.mover.resp_get_error())

1294

1295 context = self.manager.getStorageContext('Mover')

1296 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1297

1298 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

1299 context.get,

1300 self.mover.mover_name)

1301

1302 expected_calls = [mock.call(self.mover.req_get_ref())]

1303 context.conn['XML'].request.assert_has_calls(expected_calls)

1304

1305 def test_get_mover_but_not_found(self):

1306 self.hook.append(self.mover.resp_get_ref_succeed())

1307 self.hook.append(self.mover.resp_get_without_value())

1308

1309 context = self.manager.getStorageContext('Mover')

1310 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1311

1312 status, out = context.get(name=self.mover.mover_name, force=True)

1313 self.assertEqual(constants.STATUS_NOT_FOUND, status)

1314

1315 expected_calls = [

1316 mock.call(self.mover.req_get_ref()),

1317 mock.call(self.mover.req_get()),

1318 ]

1319 context.conn['XML'].request.assert_has_calls(expected_calls)

1320

1321 def test_get_mover_with_error(self):

1322 self.hook.append(self.mover.resp_get_ref_succeed())

1323 self.hook.append(self.mover.resp_get_error())

1324

1325 context = self.manager.getStorageContext('Mover')

1326 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1327

1328 status, out = context.get(self.mover.mover_name)

1329 self.assertEqual(constants.STATUS_ERROR, status)

1330

1331 expected_calls = [

1332 mock.call(self.mover.req_get_ref()),

1333 mock.call(self.mover.req_get()),

1334 ]

1335 context.conn['XML'].request.assert_has_calls(expected_calls)

1336

1337 def test_get_interconnect_id(self):

1338 self.ssh_hook.append(self.mover.output_get_interconnect_id())

1339

1340 context = self.manager.getStorageContext('Mover')

1341 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

1342

1343 conn_id = context.get_interconnect_id(self.mover.mover_name,

1344 self.mover.mover_name)

1345 self.assertEqual(self.mover.interconnect_id, conn_id)

1346

1347 ssh_calls = [mock.call(self.mover.cmd_get_interconnect_id(), False)]

1348 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

1349

1350 def test_get_physical_devices(self):

1351 self.ssh_hook.append(self.mover.output_get_physical_devices())

1352

1353 context = self.manager.getStorageContext('Mover')

1354 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

1355

1356 devices = context.get_physical_devices(self.mover.mover_name)

1357 self.assertIn(self.mover.device_name, devices)

1358

1359 ssh_calls = [mock.call(self.mover.cmd_get_physical_devices(), False)]

1360 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

1361

1362

1363class SnapshotTestCase(StorageObjectTestCaseBase):

1364 def setUp(self):

1365 super(SnapshotTestCase, self).setUp()

1366 self.hook = utils.RequestSideEffect()

1367

1368 def test_create_snapshot(self):

1369 self.hook.append(self.fs.resp_get_succeed())

1370 self.hook.append(self.snap.resp_task_succeed())

1371

1372 context = self.manager.getStorageContext('Snapshot')

1373 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1374

1375 context.create(name=self.snap.snapshot_name,

1376 fs_name=self.fs.filesystem_name,

1377 pool_id=self.pool.pool_id)

1378

1379 expected_calls = [

1380 mock.call(self.fs.req_get()),

1381 mock.call(self.snap.req_create()),

1382 ]

1383 context.conn['XML'].request.assert_has_calls(expected_calls)

1384

1385 def test_create_snapshot_but_already_exist(self):

1386 self.hook.append(self.fs.resp_get_succeed())

1387 self.hook.append(self.snap.resp_create_but_already_exist())

1388

1389 context = self.manager.getStorageContext('Snapshot')

1390 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1391

1392 context.create(name=self.snap.snapshot_name,

1393 fs_name=self.fs.filesystem_name,

1394 pool_id=self.pool.pool_id,

1395 ckpt_size=self.snap.snapshot_size)

1396

1397 expected_calls = [

1398 mock.call(self.fs.req_get()),

1399 mock.call(self.snap.req_create_with_size()),

1400 ]

1401 context.conn['XML'].request.assert_has_calls(expected_calls)

1402

1403 def test_create_snapshot_with_error(self):

1404 self.hook.append(self.fs.resp_get_succeed())

1405 self.hook.append(self.snap.resp_task_error())

1406

1407 context = self.manager.getStorageContext('Snapshot')

1408 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1409

1410 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

1411 context.create,

1412 name=self.snap.snapshot_name,

1413 fs_name=self.fs.filesystem_name,

1414 pool_id=self.pool.pool_id,

1415 ckpt_size=self.snap.snapshot_size)

1416

1417 expected_calls = [

1418 mock.call(self.fs.req_get()),

1419 mock.call(self.snap.req_create_with_size()),

1420 ]

1421 context.conn['XML'].request.assert_has_calls(expected_calls)

1422

1423 def test_get_snapshot(self):

1424 self.hook.append(self.snap.resp_get_succeed())

1425

1426 context = self.manager.getStorageContext('Snapshot')

1427 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1428

1429 status, out = context.get(self.snap.snapshot_name)

1430 self.assertEqual(constants.STATUS_OK, status)

1431 self.assertIn(self.snap.snapshot_name, context.snap_map)

1432 property_map = [

1433 'name',

1434 'id',

1435 'checkpointOf',

1436 'state',

1437 ]

1438 for prop in property_map:

1439 self.assertIn(prop, out)

1440

1441 expected_calls = [mock.call(self.snap.req_get())]

1442 context.conn['XML'].request.assert_has_calls(expected_calls)

1443

1444 def test_get_snapshot_but_not_found(self):

1445 self.hook.append(self.snap.resp_get_without_value())

1446

1447 context = self.manager.getStorageContext('Snapshot')

1448 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1449

1450 status, out = context.get(self.snap.snapshot_name)

1451 self.assertEqual(constants.STATUS_NOT_FOUND, status)

1452

1453 expected_calls = [mock.call(self.snap.req_get())]

1454 context.conn['XML'].request.assert_has_calls(expected_calls)

1455

1456 def test_get_snapshot_with_error(self):

1457 self.hook.append(self.snap.resp_get_error())

1458

1459 context = self.manager.getStorageContext('Snapshot')

1460 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1461

1462 status, out = context.get(self.snap.snapshot_name)

1463 self.assertEqual(constants.STATUS_ERROR, status)

1464

1465 expected_calls = [mock.call(self.snap.req_get())]

1466 context.conn['XML'].request.assert_has_calls(expected_calls)

1467

1468 def test_delete_snapshot(self):

1469 self.hook.append(self.snap.resp_get_succeed())

1470 self.hook.append(self.snap.resp_task_succeed())

1471

1472 context = self.manager.getStorageContext('Snapshot')

1473 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1474

1475 context.delete(self.snap.snapshot_name)

1476 self.assertNotIn(self.snap.snapshot_name, context.snap_map)

1477

1478 expected_calls = [

1479 mock.call(self.snap.req_get()),

1480 mock.call(self.snap.req_delete()),

1481 ]

1482 context.conn['XML'].request.assert_has_calls(expected_calls)

1483

1484 def test_delete_snapshot_failed_to_get_snapshot(self):

1485 self.hook.append(self.snap.resp_get_error())

1486

1487 context = self.manager.getStorageContext('Snapshot')

1488 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1489

1490 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

1491 context.delete,

1492 self.snap.snapshot_name)

1493

1494 expected_calls = [mock.call(self.snap.req_get())]

1495 context.conn['XML'].request.assert_has_calls(expected_calls)

1496

1497 def test_delete_snapshot_but_not_found(self):

1498 self.hook.append(self.snap.resp_get_without_value())

1499

1500 context = self.manager.getStorageContext('Snapshot')

1501 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1502

1503 context.delete(self.snap.snapshot_name)

1504 self.assertNotIn(self.snap.snapshot_name, context.snap_map)

1505

1506 expected_calls = [mock.call(self.snap.req_get())]

1507 context.conn['XML'].request.assert_has_calls(expected_calls)

1508

1509 def test_delete_snapshot_with_error(self):

1510 self.hook.append(self.snap.resp_get_succeed())

1511 self.hook.append(self.snap.resp_task_error())

1512

1513 context = self.manager.getStorageContext('Snapshot')

1514 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1515

1516 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

1517 context.delete,

1518 self.snap.snapshot_name)

1519

1520 expected_calls = [

1521 mock.call(self.snap.req_get()),

1522 mock.call(self.snap.req_delete()),

1523 ]

1524 context.conn['XML'].request.assert_has_calls(expected_calls)

1525

1526 def test_get_snapshot_id(self):

1527 self.hook.append(self.snap.resp_get_succeed())

1528

1529 context = self.manager.getStorageContext('Snapshot')

1530 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1531

1532 id = context.get_id(self.snap.snapshot_name)

1533 self.assertEqual(self.snap.snapshot_id, id)

1534

1535 expected_calls = [mock.call(self.snap.req_get())]

1536 context.conn['XML'].request.assert_has_calls(expected_calls)

1537

1538 def test_get_snapshot_id_with_error(self):

1539 self.hook.append(self.snap.resp_get_error())

1540

1541 context = self.manager.getStorageContext('Snapshot')

1542 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1543

1544 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

1545 context.get_id,

1546 self.snap.snapshot_name)

1547

1548 expected_calls = [mock.call(self.snap.req_get())]

1549 context.conn['XML'].request.assert_has_calls(expected_calls)

1550

1551

1552@ddt.ddt

1553class MoverInterfaceTestCase(StorageObjectTestCaseBase):

1554 def setUp(self):

1555 super(MoverInterfaceTestCase, self).setUp()

1556 self.hook = utils.RequestSideEffect()

1557

1558 def test_create_mover_interface(self):

1559 self.hook.append(self.mover.resp_get_ref_succeed())

1560 self.hook.append(self.mover.resp_task_succeed())

1561 self.hook.append(self.mover.resp_task_succeed())

1562

1563 context = self.manager.getStorageContext('MoverInterface')

1564 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1565

1566 interface = {

1567 'name': self.mover.interface_name1,

1568 'device_name': self.mover.device_name,

1569 'ip': self.mover.ip_address1,

1570 'mover_name': self.mover.mover_name,

1571 'net_mask': self.mover.net_mask,

1572 'vlan_id': self.mover.vlan_id,

1573 }

1574 context.create(interface)

1575

1576 interface['name'] = self.mover.long_interface_name

1577 context.create(interface)

1578

1579 expected_calls = [

1580 mock.call(self.mover.req_get_ref()),

1581 mock.call(self.mover.req_create_interface()),

1582 mock.call(self.mover.req_create_interface(

1583 self.mover.long_interface_name[:31])),

1584 ]

1585 context.conn['XML'].request.assert_has_calls(expected_calls)

1586

1587 def test_create_mover_interface_name_already_exist(self):

1588 self.hook.append(self.mover.resp_get_ref_succeed())

1589 self.hook.append(

1590 self.mover.resp_create_interface_but_name_already_exist())

1591

1592 context = self.manager.getStorageContext('MoverInterface')

1593 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1594

1595 interface = {

1596 'name': self.mover.interface_name1,

1597 'device_name': self.mover.device_name,

1598 'ip': self.mover.ip_address1,

1599 'mover_name': self.mover.mover_name,

1600 'net_mask': self.mover.net_mask,

1601 'vlan_id': self.mover.vlan_id,

1602 }

1603 context.create(interface)

1604

1605 expected_calls = [

1606 mock.call(self.mover.req_get_ref()),

1607 mock.call(self.mover.req_create_interface()),

1608 ]

1609 context.conn['XML'].request.assert_has_calls(expected_calls)

1610

1611 def test_create_mover_interface_ip_already_exist(self):

1612 self.hook.append(self.mover.resp_get_ref_succeed())

1613 self.hook.append(

1614 self.mover.resp_create_interface_but_ip_already_exist())

1615

1616 context = self.manager.getStorageContext('MoverInterface')

1617 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1618

1619 interface = {

1620 'name': self.mover.interface_name1,

1621 'device_name': self.mover.device_name,

1622 'ip': self.mover.ip_address1,

1623 'mover_name': self.mover.mover_name,

1624 'net_mask': self.mover.net_mask,

1625 'vlan_id': self.mover.vlan_id,

1626 }

1627 context.create(interface)

1628

1629 expected_calls = [

1630 mock.call(self.mover.req_get_ref()),

1631 mock.call(self.mover.req_create_interface()),

1632 ]

1633 context.conn['XML'].request.assert_has_calls(expected_calls)

1634

1635 @ddt.data(fakes.MoverTestData().resp_task_succeed(),

1636 fakes.MoverTestData().resp_task_error())

1637 def test_create_mover_interface_with_conflict_vlan_id(self, xml_resp):

1638 self.hook.append(self.mover.resp_get_ref_succeed())

1639 self.hook.append(

1640 self.mover.resp_create_interface_with_conflicted_vlan_id())

1641 self.hook.append(xml_resp)

1642

1643 context = self.manager.getStorageContext('MoverInterface')

1644 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1645

1646 interface = {

1647 'name': self.mover.interface_name1,

1648 'device_name': self.mover.device_name,

1649 'ip': self.mover.ip_address1,

1650 'mover_name': self.mover.mover_name,

1651 'net_mask': self.mover.net_mask,

1652 'vlan_id': self.mover.vlan_id,

1653 }

1654 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

1655 context.create,

1656 interface)

1657

1658 expected_calls = [

1659 mock.call(self.mover.req_get_ref()),

1660 mock.call(self.mover.req_create_interface()),

1661 mock.call(self.mover.req_delete_interface()),

1662 ]

1663 context.conn['XML'].request.assert_has_calls(expected_calls)

1664

1665 @mock.patch('time.sleep')

1666 def test_create_mover_interface_invalid_mover_id(self, sleep_mock):

1667 self.hook.append(self.mover.resp_get_ref_succeed())

1668 self.hook.append(self.mover.resp_invalid_mover_id())

1669 self.hook.append(self.mover.resp_get_ref_succeed())

1670 self.hook.append(self.mover.resp_task_succeed())

1671

1672 context = self.manager.getStorageContext('MoverInterface')

1673 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1674

1675 interface = {

1676 'name': self.mover.interface_name1,

1677 'device_name': self.mover.device_name,

1678 'ip': self.mover.ip_address1,

1679 'mover_name': self.mover.mover_name,

1680 'net_mask': self.mover.net_mask,

1681 'vlan_id': self.mover.vlan_id,

1682 }

1683 context.create(interface)

1684

1685 expected_calls = [

1686 mock.call(self.mover.req_get_ref()),

1687 mock.call(self.mover.req_create_interface()),

1688 mock.call(self.mover.req_get_ref()),

1689 mock.call(self.mover.req_create_interface()),

1690 ]

1691 context.conn['XML'].request.assert_has_calls(expected_calls)

1692

1693 self.assertTrue(sleep_mock.called)

1694

1695 def test_create_mover_interface_with_error(self):

1696 self.hook.append(self.mover.resp_get_ref_succeed())

1697 self.hook.append(self.mover.resp_task_error())

1698

1699 context = self.manager.getStorageContext('MoverInterface')

1700 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1701

1702 interface = {

1703 'name': self.mover.interface_name1,

1704 'device_name': self.mover.device_name,

1705 'ip': self.mover.ip_address1,

1706 'mover_name': self.mover.mover_name,

1707 'net_mask': self.mover.net_mask,

1708 'vlan_id': self.mover.vlan_id,

1709 }

1710 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

1711 context.create,

1712 interface)

1713

1714 expected_calls = [

1715 mock.call(self.mover.req_get_ref()),

1716 mock.call(self.mover.req_create_interface()),

1717 ]

1718 context.conn['XML'].request.assert_has_calls(expected_calls)

1719

1720 def test_get_mover_interface(self):

1721 self.hook.append(self.mover.resp_get_ref_succeed())

1722 self.hook.append(self.mover.resp_get_succeed())

1723 self.hook.append(self.mover.resp_get_ref_succeed())

1724 self.hook.append(self.mover.resp_get_succeed())

1725

1726 context = self.manager.getStorageContext('MoverInterface')

1727 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1728

1729 status, out = context.get(name=self.mover.interface_name1,

1730 mover_name=self.mover.mover_name)

1731 self.assertEqual(constants.STATUS_OK, status)

1732 property_map = [

1733 'name',

1734 'device',

1735 'up',

1736 'ipVersion',

1737 'netMask',

1738 'ipAddress',

1739 'vlanid',

1740 ]

1741 for prop in property_map:

1742 self.assertIn(prop, out)

1743

1744 context.get(name=self.mover.long_interface_name,

1745 mover_name=self.mover.mover_name)

1746

1747 expected_calls = [

1748 mock.call(self.mover.req_get_ref()),

1749 mock.call(self.mover.req_get()),

1750 mock.call(self.mover.req_get_ref()),

1751 mock.call(self.mover.req_get()),

1752 ]

1753 context.conn['XML'].request.assert_has_calls(expected_calls)

1754

1755 def test_get_mover_interface_not_found(self):

1756 self.hook.append(self.mover.resp_get_ref_succeed())

1757 self.hook.append(self.mover.resp_get_without_value())

1758

1759 context = self.manager.getStorageContext('MoverInterface')

1760 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1761

1762 status, out = context.get(name=self.mover.interface_name1,

1763 mover_name=self.mover.mover_name)

1764 self.assertEqual(constants.STATUS_NOT_FOUND, status)

1765

1766 expected_calls = [

1767 mock.call(self.mover.req_get_ref()),

1768 mock.call(self.mover.req_get()),

1769 ]

1770 context.conn['XML'].request.assert_has_calls(expected_calls)

1771

1772 def test_delete_mover_interface(self):

1773 self.hook.append(self.mover.resp_get_ref_succeed())

1774 self.hook.append(self.mover.resp_task_succeed())

1775

1776 context = self.manager.getStorageContext('MoverInterface')

1777 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1778

1779 context.delete(ip_addr=self.mover.ip_address1,

1780 mover_name=self.mover.mover_name)

1781

1782 expected_calls = [

1783 mock.call(self.mover.req_get_ref()),

1784 mock.call(self.mover.req_delete_interface()),

1785 ]

1786 context.conn['XML'].request.assert_has_calls(expected_calls)

1787

1788 def test_delete_mover_interface_but_nonexistent(self):

1789 self.hook.append(self.mover.resp_get_ref_succeed())

1790 self.hook.append(self.mover.resp_delete_interface_but_nonexistent())

1791

1792 context = self.manager.getStorageContext('MoverInterface')

1793 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1794

1795 context.delete(ip_addr=self.mover.ip_address1,

1796 mover_name=self.mover.mover_name)

1797

1798 expected_calls = [

1799 mock.call(self.mover.req_get_ref()),

1800 mock.call(self.mover.req_delete_interface()),

1801 ]

1802 context.conn['XML'].request.assert_has_calls(expected_calls)

1803

1804 @mock.patch('time.sleep')

1805 def test_delete_mover_interface_invalid_mover_id(self, sleep_mock):

1806 self.hook.append(self.mover.resp_get_ref_succeed())

1807 self.hook.append(self.mover.resp_invalid_mover_id())

1808 self.hook.append(self.mover.resp_get_ref_succeed())

1809 self.hook.append(self.mover.resp_task_succeed())

1810

1811 context = self.manager.getStorageContext('MoverInterface')

1812 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1813

1814 context.delete(ip_addr=self.mover.ip_address1,

1815 mover_name=self.mover.mover_name)

1816

1817 expected_calls = [

1818 mock.call(self.mover.req_get_ref()),

1819 mock.call(self.mover.req_delete_interface()),

1820 mock.call(self.mover.req_get_ref()),

1821 mock.call(self.mover.req_delete_interface()),

1822 ]

1823 context.conn['XML'].request.assert_has_calls(expected_calls)

1824

1825 self.assertTrue(sleep_mock.called)

1826

1827 def test_delete_mover_interface_with_error(self):

1828 self.hook.append(self.mover.resp_get_ref_succeed())

1829 self.hook.append(self.mover.resp_task_error())

1830

1831 context = self.manager.getStorageContext('MoverInterface')

1832 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1833

1834 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

1835 context.delete,

1836 ip_addr=self.mover.ip_address1,

1837 mover_name=self.mover.mover_name)

1838

1839 expected_calls = [

1840 mock.call(self.mover.req_get_ref()),

1841 mock.call(self.mover.req_delete_interface()),

1842 ]

1843 context.conn['XML'].request.assert_has_calls(expected_calls)

1844

1845

1846class DNSDomainTestCase(StorageObjectTestCaseBase):

1847 def setUp(self):

1848 super(DNSDomainTestCase, self).setUp()

1849 self.hook = utils.RequestSideEffect()

1850

1851 def test_create_dns_domain(self):

1852 self.hook.append(self.mover.resp_get_ref_succeed())

1853 self.hook.append(self.dns.resp_task_succeed())

1854

1855 context = self.manager.getStorageContext('DNSDomain')

1856 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1857

1858 context.create(mover_name=self.mover.mover_name,

1859 name=self.dns.domain_name,

1860 servers=self.dns.dns_ip_address)

1861

1862 expected_calls = [

1863 mock.call(self.mover.req_get_ref()),

1864 mock.call(self.dns.req_create()),

1865 ]

1866 context.conn['XML'].request.assert_has_calls(expected_calls)

1867

1868 @mock.patch('time.sleep')

1869 def test_create_dns_domain_invalid_mover_id(self, sleep_mock):

1870 self.hook.append(self.mover.resp_get_ref_succeed())

1871 self.hook.append(self.dns.resp_invalid_mover_id())

1872 self.hook.append(self.mover.resp_get_ref_succeed())

1873 self.hook.append(self.dns.resp_task_succeed())

1874

1875 context = self.manager.getStorageContext('DNSDomain')

1876 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1877

1878 context.create(mover_name=self.mover.mover_name,

1879 name=self.dns.domain_name,

1880 servers=self.dns.dns_ip_address)

1881

1882 expected_calls = [

1883 mock.call(self.mover.req_get_ref()),

1884 mock.call(self.dns.req_create()),

1885 mock.call(self.mover.req_get_ref()),

1886 mock.call(self.dns.req_create()),

1887 ]

1888 context.conn['XML'].request.assert_has_calls(expected_calls)

1889

1890 self.assertTrue(sleep_mock.called)

1891

1892 def test_create_dns_domain_with_error(self):

1893 self.hook.append(self.mover.resp_get_ref_succeed())

1894 self.hook.append(self.dns.resp_task_error())

1895

1896 context = self.manager.getStorageContext('DNSDomain')

1897 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1898

1899 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

1900 context.create,

1901 mover_name=self.mover.mover_name,

1902 name=self.mover.domain_name,

1903 servers=self.dns.dns_ip_address)

1904

1905 expected_calls = [

1906 mock.call(self.mover.req_get_ref()),

1907 mock.call(self.dns.req_create()),

1908 ]

1909 context.conn['XML'].request.assert_has_calls(expected_calls)

1910

1911 def test_delete_dns_domain(self):

1912 self.hook.append(self.mover.resp_get_ref_succeed())

1913 self.hook.append(self.dns.resp_task_succeed())

1914 self.hook.append(self.dns.resp_task_error())

1915

1916 context = self.manager.getStorageContext('DNSDomain')

1917 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1918

1919 context.delete(mover_name=self.mover.mover_name,

1920 name=self.mover.domain_name)

1921

1922 context.delete(mover_name=self.mover.mover_name,

1923 name=self.mover.domain_name)

1924

1925 expected_calls = [

1926 mock.call(self.mover.req_get_ref()),

1927 mock.call(self.dns.req_delete()),

1928 mock.call(self.dns.req_delete()),

1929 ]

1930 context.conn['XML'].request.assert_has_calls(expected_calls)

1931

1932 @mock.patch('time.sleep')

1933 def test_delete_dns_domain_invalid_mover_id(self, sleep_mock):

1934 self.hook.append(self.mover.resp_get_ref_succeed())

1935 self.hook.append(self.dns.resp_invalid_mover_id())

1936 self.hook.append(self.mover.resp_get_ref_succeed())

1937 self.hook.append(self.dns.resp_task_succeed())

1938

1939 context = self.manager.getStorageContext('DNSDomain')

1940 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1941

1942 context.delete(mover_name=self.mover.mover_name,

1943 name=self.mover.domain_name)

1944

1945 expected_calls = [

1946 mock.call(self.mover.req_get_ref()),

1947 mock.call(self.dns.req_delete()),

1948 mock.call(self.mover.req_get_ref()),

1949 mock.call(self.dns.req_delete()),

1950 ]

1951 context.conn['XML'].request.assert_has_calls(expected_calls)

1952

1953 self.assertTrue(sleep_mock.called)

1954

1955

1956class CIFSServerTestCase(StorageObjectTestCaseBase):

1957 def setUp(self):

1958 super(CIFSServerTestCase, self).setUp()

1959 self.hook = utils.RequestSideEffect()

1960

1961 def test_create_cifs_server(self):

1962 self.hook.append(self.mover.resp_get_ref_succeed())

1963 self.hook.append(self.cifs_server.resp_task_succeed())

1964 self.hook.append(self.vdm.resp_get_succeed())

1965 self.hook.append(self.cifs_server.resp_task_succeed())

1966 self.hook.append(self.cifs_server.resp_task_error())

1967 self.hook.append(self.cifs_server.resp_get_succeed(

1968 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True))

1969

1970 context = self.manager.getStorageContext('CIFSServer')

1971 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

1972

1973 # Create CIFS server on mover

1974 cifs_server_args = {

1975 'name': self.cifs_server.cifs_server_name,

1976 'interface_ip': self.cifs_server.ip_address1,

1977 'domain_name': self.cifs_server.domain_name,

1978 'user_name': self.cifs_server.domain_user,

1979 'password': self.cifs_server.domain_password,

1980 'mover_name': self.mover.mover_name,

1981 'is_vdm': False,

1982 }

1983 context.create(cifs_server_args)

1984

1985 # Create CIFS server on VDM

1986 cifs_server_args = {

1987 'name': self.cifs_server.cifs_server_name,

1988 'interface_ip': self.cifs_server.ip_address1,

1989 'domain_name': self.cifs_server.domain_name,

1990 'user_name': self.cifs_server.domain_user,

1991 'password': self.cifs_server.domain_password,

1992 'mover_name': self.vdm.vdm_name,

1993 'is_vdm': True,

1994 }

1995 context.create(cifs_server_args)

1996

1997 # Create CIFS server on VDM

1998 cifs_server_args = {

1999 'name': self.cifs_server.cifs_server_name,

2000 'interface_ip': self.cifs_server.ip_address1,

2001 'domain_name': self.cifs_server.domain_name,

2002 'user_name': self.cifs_server.domain_user,

2003 'password': self.cifs_server.domain_password,

2004 'mover_name': self.vdm.vdm_name,

2005 'is_vdm': True,

2006 }

2007 context.create(cifs_server_args)

2008

2009 expected_calls = [

2010 mock.call(self.mover.req_get_ref()),

2011 mock.call(self.cifs_server.req_create(self.mover.mover_id, False)),

2012 mock.call(self.vdm.req_get()),

2013 mock.call(self.cifs_server.req_create(self.vdm.vdm_id)),

2014 mock.call(self.cifs_server.req_create(self.vdm.vdm_id)),

2015 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

2016 ]

2017 context.conn['XML'].request.assert_has_calls(expected_calls)

2018

2019 def test_create_cifs_server_already_exist(self):

2020 self.hook.append(self.vdm.resp_get_succeed())

2021 self.hook.append(self.cifs_server.resp_task_error())

2022 self.hook.append(self.cifs_server.resp_get_succeed(

2023 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True))

2024

2025 context = self.manager.getStorageContext('CIFSServer')

2026 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2027

2028 @mock.patch('time.sleep')

2029 def test_create_cifs_server_invalid_mover_id(self, sleep_mock):

2030 self.hook.append(self.mover.resp_get_ref_succeed())

2031 self.hook.append(self.cifs_server.resp_invalid_mover_id())

2032 self.hook.append(self.mover.resp_get_ref_succeed())

2033 self.hook.append(self.cifs_server.resp_task_succeed())

2034

2035 context = self.manager.getStorageContext('CIFSServer')

2036 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2037

2038 # Create CIFS server on mover

2039 cifs_server_args = {

2040 'name': self.cifs_server.cifs_server_name,

2041 'interface_ip': self.cifs_server.ip_address1,

2042 'domain_name': self.cifs_server.domain_name,

2043 'user_name': self.cifs_server.domain_user,

2044 'password': self.cifs_server.domain_password,

2045 'mover_name': self.mover.mover_name,

2046 'is_vdm': False,

2047 }

2048 context.create(cifs_server_args)

2049

2050 expected_calls = [

2051 mock.call(self.mover.req_get_ref()),

2052 mock.call(self.cifs_server.req_create(self.mover.mover_id, False)),

2053 mock.call(self.mover.req_get_ref()),

2054 mock.call(self.cifs_server.req_create(self.mover.mover_id, False)),

2055 ]

2056 context.conn['XML'].request.assert_has_calls(expected_calls)

2057

2058 self.assertTrue(sleep_mock.called)

2059

2060 def test_create_cifs_server_with_error(self):

2061 self.hook.append(self.vdm.resp_get_succeed())

2062 self.hook.append(self.cifs_server.resp_task_error())

2063 self.hook.append(self.cifs_server.resp_get_error())

2064

2065 context = self.manager.getStorageContext('CIFSServer')

2066 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2067

2068 # Create CIFS server on VDM

2069 cifs_server_args = {

2070 'name': self.cifs_server.cifs_server_name,

2071 'interface_ip': self.cifs_server.ip_address1,

2072 'domain_name': self.cifs_server.domain_name,

2073 'user_name': self.cifs_server.domain_user,

2074 'password': self.cifs_server.domain_password,

2075 'mover_name': self.vdm.vdm_name,

2076 'is_vdm': True,

2077 }

2078 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

2079 context.create,

2080 cifs_server_args)

2081

2082 expected_calls = [

2083 mock.call(self.vdm.req_get()),

2084 mock.call(self.cifs_server.req_create(self.vdm.vdm_id)),

2085 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

2086 ]

2087 context.conn['XML'].request.assert_has_calls(expected_calls)

2088

2089 def test_get_all_cifs_server(self):

2090 self.hook.append(self.vdm.resp_get_succeed())

2091 self.hook.append(self.cifs_server.resp_get_succeed(

2092 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True))

2093 self.hook.append(self.cifs_server.resp_get_succeed(

2094 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True))

2095

2096 context = self.manager.getStorageContext('CIFSServer')

2097 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2098

2099 status, out = context.get_all(self.vdm.vdm_name)

2100 self.assertEqual(constants.STATUS_OK, status)

2101 self.assertIn(self.vdm.vdm_name, context.cifs_server_map)

2102

2103 # Get CIFS server from the cache

2104 status, out = context.get_all(self.vdm.vdm_name)

2105 self.assertEqual(constants.STATUS_OK, status)

2106 self.assertIn(self.vdm.vdm_name, context.cifs_server_map)

2107

2108 expected_calls = [

2109 mock.call(self.vdm.req_get()),

2110 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

2111 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

2112 ]

2113 context.conn['XML'].request.assert_has_calls(expected_calls)

2114

2115 @mock.patch('time.sleep')

2116 def test_get_all_cifs_server_invalid_mover_id(self, sleep_mock):

2117 self.hook.append(self.mover.resp_get_ref_succeed())

2118 self.hook.append(self.cifs_server.resp_invalid_mover_id())

2119 self.hook.append(self.mover.resp_get_ref_succeed())

2120 self.hook.append(self.cifs_server.resp_get_succeed(

2121 mover_id=self.mover.mover_id, is_vdm=False, join_domain=True))

2122

2123 context = self.manager.getStorageContext('CIFSServer')

2124 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2125

2126 status, out = context.get_all(self.mover.mover_name, False)

2127 self.assertEqual(constants.STATUS_OK, status)

2128 self.assertIn(self.mover.mover_name, context.cifs_server_map)

2129

2130 expected_calls = [

2131 mock.call(self.mover.req_get_ref()),

2132 mock.call(self.cifs_server.req_get(self.mover.mover_id, False)),

2133 mock.call(self.mover.req_get_ref()),

2134 mock.call(self.cifs_server.req_get(self.mover.mover_id, False)),

2135 ]

2136 context.conn['XML'].request.assert_has_calls(expected_calls)

2137

2138 self.assertTrue(sleep_mock.called)

2139

2140 def test_get_cifs_server(self):

2141 self.hook.append(self.vdm.resp_get_succeed())

2142 self.hook.append(self.cifs_server.resp_get_succeed(

2143 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True))

2144

2145 context = self.manager.getStorageContext('CIFSServer')

2146 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2147

2148 status, out = context.get(name=self.cifs_server.cifs_server_name,

2149 mover_name=self.vdm.vdm_name)

2150 self.assertEqual(constants.STATUS_OK, status)

2151 property_map = {

2152 'name',

2153 'compName',

2154 'Aliases',

2155 'type',

2156 'interfaces',

2157 'domain',

2158 'domainJoined',

2159 'mover',

2160 'moverIdIsVdm',

2161 }

2162 for prop in property_map:

2163 self.assertIn(prop, out)

2164

2165 context.get(name=self.cifs_server.cifs_server_name,

2166 mover_name=self.vdm.vdm_name)

2167

2168 expected_calls = [

2169 mock.call(self.vdm.req_get()),

2170 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

2171 ]

2172 context.conn['XML'].request.assert_has_calls(expected_calls)

2173

2174 def test_modify_cifs_server(self):

2175 self.hook.append(self.mover.resp_get_ref_succeed())

2176 self.hook.append(self.cifs_server.resp_task_succeed())

2177 self.hook.append(self.vdm.resp_get_succeed())

2178 self.hook.append(self.cifs_server.resp_task_succeed())

2179

2180 context = self.manager.getStorageContext('CIFSServer')

2181 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2182

2183 cifs_server_args = {

2184 'name': self.cifs_server.cifs_server_name[-14:],

2185 'join_domain': True,

2186 'user_name': self.cifs_server.domain_user,

2187 'password': self.cifs_server.domain_password,

2188 'mover_name': self.mover.mover_name,

2189 'is_vdm': False,

2190 }

2191 context.modify(cifs_server_args)

2192

2193 cifs_server_args = {

2194 'name': self.cifs_server.cifs_server_name[-14:],

2195 'join_domain': False,

2196 'user_name': self.cifs_server.domain_user,

2197 'password': self.cifs_server.domain_password,

2198 'mover_name': self.vdm.vdm_name,

2199 }

2200 context.modify(cifs_server_args)

2201

2202 expected_calls = [

2203 mock.call(self.mover.req_get_ref()),

2204 mock.call(self.cifs_server.req_modify(

2205 mover_id=self.mover.mover_id, is_vdm=False, join_domain=True)),

2206 mock.call(self.vdm.req_get()),

2207 mock.call(self.cifs_server.req_modify(

2208 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=False)),

2209 ]

2210 context.conn['XML'].request.assert_has_calls(expected_calls)

2211

2212 def test_modify_cifs_server_but_unjoin_domain(self):

2213 self.hook.append(self.vdm.resp_get_succeed())

2214 self.hook.append(self.cifs_server.resp_modify_but_unjoin_domain())

2215

2216 context = self.manager.getStorageContext('CIFSServer')

2217 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2218

2219 cifs_server_args = {

2220 'name': self.cifs_server.cifs_server_name[-14:],

2221 'join_domain': False,

2222 'user_name': self.cifs_server.domain_user,

2223 'password': self.cifs_server.domain_password,

2224 'mover_name': self.vdm.vdm_name,

2225 }

2226

2227 context.modify(cifs_server_args)

2228

2229 expected_calls = [

2230 mock.call(self.vdm.req_get()),

2231 mock.call(self.cifs_server.req_modify(

2232 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=False)),

2233 ]

2234 context.conn['XML'].request.assert_has_calls(expected_calls)

2235

2236 def test_modify_cifs_server_but_already_join_domain(self):

2237 self.hook.append(self.vdm.resp_get_succeed())

2238 self.hook.append(

2239 self.cifs_server.resp_modify_but_already_join_domain())

2240

2241 context = self.manager.getStorageContext('CIFSServer')

2242 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2243

2244 cifs_server_args = {

2245 'name': self.cifs_server.cifs_server_name[-14:],

2246 'join_domain': True,

2247 'user_name': self.cifs_server.domain_user,

2248 'password': self.cifs_server.domain_password,

2249 'mover_name': self.vdm.vdm_name,

2250 }

2251

2252 context.modify(cifs_server_args)

2253

2254 expected_calls = [

2255 mock.call(self.vdm.req_get()),

2256 mock.call(self.cifs_server.req_modify(

2257 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=True)),

2258 ]

2259 context.conn['XML'].request.assert_has_calls(expected_calls)

2260

2261 @mock.patch('time.sleep')

2262 def test_modify_cifs_server_invalid_mover_id(self, sleep_mock):

2263 self.hook.append(self.mover.resp_get_ref_succeed())

2264 self.hook.append(self.cifs_server.resp_invalid_mover_id())

2265 self.hook.append(self.mover.resp_get_ref_succeed())

2266 self.hook.append(self.cifs_server.resp_task_succeed())

2267

2268 context = self.manager.getStorageContext('CIFSServer')

2269 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2270

2271 cifs_server_args = {

2272 'name': self.cifs_server.cifs_server_name[-14:],

2273 'join_domain': True,

2274 'user_name': self.cifs_server.domain_user,

2275 'password': self.cifs_server.domain_password,

2276 'mover_name': self.mover.mover_name,

2277 'is_vdm': False,

2278 }

2279 context.modify(cifs_server_args)

2280

2281 expected_calls = [

2282 mock.call(self.mover.req_get_ref()),

2283 mock.call(self.cifs_server.req_modify(

2284 mover_id=self.mover.mover_id, is_vdm=False, join_domain=True)),

2285 mock.call(self.mover.req_get_ref()),

2286 mock.call(self.cifs_server.req_modify(

2287 mover_id=self.mover.mover_id, is_vdm=False, join_domain=True)),

2288 ]

2289 context.conn['XML'].request.assert_has_calls(expected_calls)

2290

2291 self.assertTrue(sleep_mock.called)

2292

2293 def test_modify_cifs_server_with_error(self):

2294 self.hook.append(self.vdm.resp_get_succeed())

2295 self.hook.append(self.cifs_server.resp_task_error())

2296

2297 context = self.manager.getStorageContext('CIFSServer')

2298 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2299

2300 cifs_server_args = {

2301 'name': self.cifs_server.cifs_server_name[-14:],

2302 'join_domain': False,

2303 'user_name': self.cifs_server.domain_user,

2304 'password': self.cifs_server.domain_password,

2305 'mover_name': self.vdm.vdm_name,

2306 }

2307 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

2308 context.modify,

2309 cifs_server_args)

2310

2311 expected_calls = [

2312 mock.call(self.vdm.req_get()),

2313 mock.call(self.cifs_server.req_modify(

2314 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=False)),

2315 ]

2316 context.conn['XML'].request.assert_has_calls(expected_calls)

2317

2318 def test_delete_cifs_server(self):

2319 self.hook.append(self.mover.resp_get_ref_succeed())

2320 self.hook.append(self.cifs_server.resp_get_succeed(

2321 mover_id=self.mover.mover_id, is_vdm=False, join_domain=True))

2322 self.hook.append(self.cifs_server.resp_task_succeed())

2323 self.hook.append(self.vdm.resp_get_succeed())

2324 self.hook.append(self.cifs_server.resp_get_succeed(

2325 mover_id=self.vdm.vdm_id, is_vdm=True, join_domain=False))

2326 self.hook.append(self.cifs_server.resp_task_succeed())

2327

2328 context = self.manager.getStorageContext('CIFSServer')

2329 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2330

2331 context.delete(computer_name=self.cifs_server.cifs_server_name,

2332 mover_name=self.mover.mover_name,

2333 is_vdm=False)

2334

2335 context.delete(computer_name=self.cifs_server.cifs_server_name,

2336 mover_name=self.vdm.vdm_name)

2337

2338 expected_calls = [

2339 mock.call(self.mover.req_get_ref()),

2340 mock.call(self.cifs_server.req_get(self.mover.mover_id, False)),

2341 mock.call(self.cifs_server.req_delete(self.mover.mover_id, False)),

2342 mock.call(self.vdm.req_get()),

2343 mock.call(self.cifs_server.req_get(self.vdm.vdm_id)),

2344 mock.call(self.cifs_server.req_delete(self.vdm.vdm_id)),

2345 ]

2346 context.conn['XML'].request.assert_has_calls(expected_calls)

2347

2348 def test_delete_cifs_server_but_not_found(self):

2349 self.hook.append(self.mover.resp_get_without_value())

2350 self.hook.append(self.mover.resp_get_ref_succeed())

2351 self.hook.append(self.cifs_server.resp_get_without_value())

2352

2353 context = self.manager.getStorageContext('CIFSServer')

2354 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2355

2356 context.delete(computer_name=self.cifs_server.cifs_server_name,

2357 mover_name=self.mover.mover_name,

2358 is_vdm=False)

2359

2360 context.delete(computer_name=self.cifs_server.cifs_server_name,

2361 mover_name=self.mover.mover_name,

2362 is_vdm=False)

2363

2364 expected_calls = [

2365 mock.call(self.mover.req_get_ref()),

2366 mock.call(self.mover.req_get_ref()),

2367 mock.call(self.cifs_server.req_get(self.mover.mover_id, False)),

2368 ]

2369 context.conn['XML'].request.assert_has_calls(expected_calls)

2370

2371 def test_delete_cifs_server_with_error(self):

2372 self.hook.append(self.mover.resp_get_ref_succeed())

2373 self.hook.append(self.cifs_server.resp_get_succeed(

2374 mover_id=self.mover.mover_id, is_vdm=False, join_domain=True))

2375 self.hook.append(self.cifs_server.resp_task_error())

2376

2377 context = self.manager.getStorageContext('CIFSServer')

2378 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2379

2380 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

2381 context.delete,

2382 computer_name=self.cifs_server.cifs_server_name,

2383 mover_name=self.mover.mover_name,

2384 is_vdm=False)

2385

2386 expected_calls = [

2387 mock.call(self.mover.req_get_ref()),

2388 mock.call(self.cifs_server.req_get(self.mover.mover_id, False)),

2389 mock.call(self.cifs_server.req_delete(self.mover.mover_id, False)),

2390 ]

2391 context.conn['XML'].request.assert_has_calls(expected_calls)

2392

2393

2394class CIFSShareTestCase(StorageObjectTestCaseBase):

2395 def setUp(self):

2396 super(CIFSShareTestCase, self).setUp()

2397 self.hook = utils.RequestSideEffect()

2398 self.ssh_hook = utils.SSHSideEffect()

2399

2400 def test_create_cifs_share(self):

2401 self.hook.append(self.vdm.resp_get_succeed())

2402 self.hook.append(self.cifs_share.resp_task_succeed())

2403 self.hook.append(self.mover.resp_get_ref_succeed())

2404 self.hook.append(self.cifs_share.resp_task_succeed())

2405

2406 context = self.manager.getStorageContext('CIFSShare')

2407 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2408

2409 context.create(name=self.cifs_share.share_name,

2410 server_name=self.cifs_share.cifs_server_name[-14:],

2411 mover_name=self.vdm.vdm_name,

2412 is_vdm=True)

2413

2414 context.create(name=self.cifs_share.share_name,

2415 server_name=self.cifs_share.cifs_server_name[-14:],

2416 mover_name=self.mover.mover_name,

2417 is_vdm=False)

2418

2419 expected_calls = [

2420 mock.call(self.vdm.req_get()),

2421 mock.call(self.cifs_share.req_create(self.vdm.vdm_id)),

2422 mock.call(self.mover.req_get_ref()),

2423 mock.call(self.cifs_share.req_create(self.mover.mover_id, False)),

2424 ]

2425 context.conn['XML'].request.assert_has_calls(expected_calls)

2426

2427 @mock.patch('time.sleep')

2428 def test_create_cifs_share_invalid_mover_id(self, sleep_mock):

2429 self.hook.append(self.mover.resp_get_ref_succeed())

2430 self.hook.append(self.cifs_share.resp_invalid_mover_id())

2431 self.hook.append(self.mover.resp_get_ref_succeed())

2432 self.hook.append(self.cifs_share.resp_task_succeed())

2433

2434 context = self.manager.getStorageContext('CIFSShare')

2435 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2436

2437 context.create(name=self.cifs_share.share_name,

2438 server_name=self.cifs_share.cifs_server_name[-14:],

2439 mover_name=self.mover.mover_name,

2440 is_vdm=False)

2441

2442 expected_calls = [

2443 mock.call(self.mover.req_get_ref()),

2444 mock.call(self.cifs_share.req_create(self.mover.mover_id, False)),

2445 mock.call(self.mover.req_get_ref()),

2446 mock.call(self.cifs_share.req_create(self.mover.mover_id, False)),

2447 ]

2448 context.conn['XML'].request.assert_has_calls(expected_calls)

2449

2450 self.assertTrue(sleep_mock.called)

2451

2452 def test_create_cifs_share_with_error(self):

2453 self.hook.append(self.vdm.resp_get_succeed())

2454 self.hook.append(self.cifs_share.resp_task_error())

2455

2456 context = self.manager.getStorageContext('CIFSShare')

2457 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2458

2459 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

2460 context.create,

2461 name=self.cifs_share.share_name,

2462 server_name=self.cifs_share.cifs_server_name[-14:],

2463 mover_name=self.vdm.vdm_name,

2464 is_vdm=True)

2465

2466 expected_calls = [

2467 mock.call(self.vdm.req_get()),

2468 mock.call(self.cifs_share.req_create(self.vdm.vdm_id)),

2469 ]

2470 context.conn['XML'].request.assert_has_calls(expected_calls)

2471

2472 def test_delete_cifs_share(self):

2473 self.hook.append(self.cifs_share.resp_get_succeed(self.vdm.vdm_id))

2474 self.hook.append(self.vdm.resp_get_succeed())

2475 self.hook.append(self.cifs_share.resp_task_succeed())

2476 self.hook.append(self.cifs_share.resp_get_succeed(self.mover.mover_id,

2477 False))

2478 self.hook.append(self.mover.resp_get_ref_succeed())

2479 self.hook.append(self.cifs_share.resp_task_succeed())

2480

2481 context = self.manager.getStorageContext('CIFSShare')

2482 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2483

2484 context.delete(name=self.cifs_share.share_name,

2485 mover_name=self.vdm.vdm_name,

2486 is_vdm=True)

2487

2488 context.delete(name=self.cifs_share.share_name,

2489 mover_name=self.mover.mover_name,

2490 is_vdm=False)

2491

2492 expected_calls = [

2493 mock.call(self.cifs_share.req_get()),

2494 mock.call(self.vdm.req_get()),

2495 mock.call(self.cifs_share.req_delete(self.vdm.vdm_id)),

2496 mock.call(self.cifs_share.req_get()),

2497 mock.call(self.mover.req_get_ref()),

2498 mock.call(self.cifs_share.req_delete(self.mover.mover_id, False)),

2499 ]

2500 context.conn['XML'].request.assert_has_calls(expected_calls)

2501

2502 def test_delete_cifs_share_not_found(self):

2503 self.hook.append(self.cifs_share.resp_get_error())

2504 self.hook.append(self.cifs_share.resp_get_without_value())

2505

2506 context = self.manager.getStorageContext('CIFSShare')

2507 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2508

2509 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

2510 context.delete,

2511 name=self.cifs_share.share_name,

2512 mover_name=self.vdm.vdm_name,

2513 is_vdm=True)

2514

2515 context.delete(name=self.cifs_share.share_name,

2516 mover_name=self.vdm.vdm_name,

2517 is_vdm=True)

2518

2519 expected_calls = [

2520 mock.call(self.cifs_share.req_get()),

2521 mock.call(self.cifs_share.req_get()),

2522 ]

2523 context.conn['XML'].request.assert_has_calls(expected_calls)

2524

2525 @mock.patch('time.sleep')

2526 def test_delete_cifs_share_invalid_mover_id(self, sleep_mock):

2527 self.hook.append(self.cifs_share.resp_get_succeed(self.mover.mover_id,

2528 False))

2529 self.hook.append(self.mover.resp_get_ref_succeed())

2530 self.hook.append(self.cifs_share.resp_invalid_mover_id())

2531 self.hook.append(self.mover.resp_get_ref_succeed())

2532 self.hook.append(self.cifs_share.resp_task_succeed())

2533

2534 context = self.manager.getStorageContext('CIFSShare')

2535 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2536

2537 context.delete(name=self.cifs_share.share_name,

2538 mover_name=self.mover.mover_name,

2539 is_vdm=False)

2540

2541 expected_calls = [

2542 mock.call(self.cifs_share.req_get()),

2543 mock.call(self.mover.req_get_ref()),

2544 mock.call(self.cifs_share.req_delete(self.mover.mover_id, False)),

2545 mock.call(self.mover.req_get_ref()),

2546 mock.call(self.cifs_share.req_delete(self.mover.mover_id, False)),

2547 ]

2548 context.conn['XML'].request.assert_has_calls(expected_calls)

2549

2550 self.assertTrue(sleep_mock.called)

2551

2552 def test_delete_cifs_share_with_error(self):

2553 self.hook.append(self.cifs_share.resp_get_succeed(self.vdm.vdm_id))

2554 self.hook.append(self.vdm.resp_get_succeed())

2555 self.hook.append(self.cifs_share.resp_task_error())

2556

2557 context = self.manager.getStorageContext('CIFSShare')

2558 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2559

2560 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

2561 context.delete,

2562 name=self.cifs_share.share_name,

2563 mover_name=self.vdm.vdm_name,

2564 is_vdm=True)

2565

2566 expected_calls = [

2567 mock.call(self.cifs_share.req_get()),

2568 mock.call(self.vdm.req_get()),

2569 mock.call(self.cifs_share.req_delete(self.vdm.vdm_id)),

2570 ]

2571 context.conn['XML'].request.assert_has_calls(expected_calls)

2572

2573 def test_get_cifs_share(self):

2574 self.hook.append(self.cifs_share.resp_get_succeed(self.vdm.vdm_id))

2575

2576 context = self.manager.getStorageContext('CIFSShare')

2577 context.conn['XML'].request = utils.EMCMock(side_effect=self.hook)

2578

2579 context.get(self.cifs_share.share_name)

2580

2581 expected_calls = [mock.call(self.cifs_share.req_get())]

2582 context.conn['XML'].request.assert_has_calls(expected_calls)

2583

2584 def test_disable_share_access(self):

2585 self.ssh_hook.append('Command succeeded')

2586

2587 context = self.manager.getStorageContext('CIFSShare')

2588 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

2589

2590 context.disable_share_access(share_name=self.cifs_share.share_name,

2591 mover_name=self.vdm.vdm_name)

2592

2593 ssh_calls = [mock.call(self.cifs_share.cmd_disable_access(), True)]

2594 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

2595

2596 def test_disable_share_access_with_error(self):

2597 self.ssh_hook.append(ex=processutils.ProcessExecutionError(

2598 stdout=self.cifs_share.fake_output))

2599

2600 context = self.manager.getStorageContext('CIFSShare')

2601 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

2602

2603 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

2604 context.disable_share_access,

2605 share_name=self.cifs_share.share_name,

2606 mover_name=self.vdm.vdm_name)

2607

2608 ssh_calls = [mock.call(self.cifs_share.cmd_disable_access(), True)]

2609 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

2610

2611 def test_allow_share_access(self):

2612 self.ssh_hook.append(self.cifs_share.output_allow_access())

2613

2614 context = self.manager.getStorageContext('CIFSShare')

2615 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

2616

2617 context.allow_share_access(mover_name=self.vdm.vdm_name,

2618 share_name=self.cifs_share.share_name,

2619 user_name=self.cifs_server.domain_user,

2620 domain=self.cifs_server.domain_name,

2621 access=constants.CIFS_ACL_FULLCONTROL)

2622

2623 ssh_calls = [mock.call(self.cifs_share.cmd_change_access(), True)]

2624 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

2625

2626 def test_allow_share_access_duplicate_ACE(self):

2627 expt_dup_ace = processutils.ProcessExecutionError(

2628 stdout=self.cifs_share.output_allow_access_but_duplicate_ace())

2629 self.ssh_hook.append(ex=expt_dup_ace)

2630

2631 context = self.manager.getStorageContext('CIFSShare')

2632 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

2633

2634 context.allow_share_access(mover_name=self.vdm.vdm_name,

2635 share_name=self.cifs_share.share_name,

2636 user_name=self.cifs_server.domain_user,

2637 domain=self.cifs_server.domain_name,

2638 access=constants.CIFS_ACL_FULLCONTROL)

2639

2640 ssh_calls = [mock.call(self.cifs_share.cmd_change_access(), True)]

2641 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

2642

2643 def test_allow_share_access_with_error(self):

2644 expt_err = processutils.ProcessExecutionError(

2645 self.cifs_share.fake_output)

2646 self.ssh_hook.append(ex=expt_err)

2647

2648 context = self.manager.getStorageContext('CIFSShare')

2649 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

2650

2651 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

2652 context.allow_share_access,

2653 mover_name=self.vdm.vdm_name,

2654 share_name=self.cifs_share.share_name,

2655 user_name=self.cifs_server.domain_user,

2656 domain=self.cifs_server.domain_name,

2657 access=constants.CIFS_ACL_FULLCONTROL)

2658

2659 ssh_calls = [mock.call(self.cifs_share.cmd_change_access(), True)]

2660 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

2661

2662 def test_deny_share_access(self):

2663 self.ssh_hook.append('Command succeeded')

2664

2665 context = self.manager.getStorageContext('CIFSShare')

2666 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

2667

2668 context.deny_share_access(mover_name=self.vdm.vdm_name,

2669 share_name=self.cifs_share.share_name,

2670 user_name=self.cifs_server.domain_user,

2671 domain=self.cifs_server.domain_name,

2672 access=constants.CIFS_ACL_FULLCONTROL)

2673

2674 ssh_calls = [

2675 mock.call(self.cifs_share.cmd_change_access(action='revoke'),

2676 True),

2677 ]

2678 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

2679

2680 def test_deny_share_access_no_ace(self):

2681 expt_no_ace = processutils.ProcessExecutionError(

2682 stdout=self.cifs_share.output_deny_access_but_no_ace())

2683 self.ssh_hook.append(ex=expt_no_ace)

2684

2685 context = self.manager.getStorageContext('CIFSShare')

2686 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

2687

2688 context.deny_share_access(mover_name=self.vdm.vdm_name,

2689 share_name=self.cifs_share.share_name,

2690 user_name=self.cifs_server.domain_user,

2691 domain=self.cifs_server.domain_name,

2692 access=constants.CIFS_ACL_FULLCONTROL)

2693

2694 ssh_calls = [

2695 mock.call(self.cifs_share.cmd_change_access(action='revoke'),

2696 True),

2697 ]

2698 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

2699

2700 def test_deny_share_access_but_no_user_found(self):

2701 expt_no_user = processutils.ProcessExecutionError(

2702 stdout=self.cifs_share.output_deny_access_but_no_user_found())

2703 self.ssh_hook.append(ex=expt_no_user)

2704

2705 context = self.manager.getStorageContext('CIFSShare')

2706 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

2707

2708 context.deny_share_access(mover_name=self.vdm.vdm_name,

2709 share_name=self.cifs_share.share_name,

2710 user_name=self.cifs_server.domain_user,

2711 domain=self.cifs_server.domain_name,

2712 access=constants.CIFS_ACL_FULLCONTROL)

2713

2714 ssh_calls = [

2715 mock.call(self.cifs_share.cmd_change_access(action='revoke'),

2716 True),

2717 ]

2718 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

2719

2720 def test_deny_share_access_with_error(self):

2721 expt_err = processutils.ProcessExecutionError(

2722 self.cifs_share.fake_output)

2723 self.ssh_hook.append(ex=expt_err)

2724

2725 context = self.manager.getStorageContext('CIFSShare')

2726 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

2727

2728 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

2729 context.deny_share_access,

2730 mover_name=self.vdm.vdm_name,

2731 share_name=self.cifs_share.share_name,

2732 user_name=self.cifs_server.domain_user,

2733 domain=self.cifs_server.domain_name,

2734 access=constants.CIFS_ACL_FULLCONTROL)

2735

2736 ssh_calls = [

2737 mock.call(self.cifs_share.cmd_change_access(action='revoke'),

2738 True),

2739 ]

2740 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

2741

2742 def test_get_share_access(self):

2743 self.ssh_hook.append(fakes.FakeData.cifs_access)

2744

2745 context = self.manager.getStorageContext('CIFSShare')

2746 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

2747

2748 ret = context.get_share_access(

2749 mover_name=self.vdm.vdm_name,

2750 share_name=self.cifs_share.share_name)

2751

2752 ssh_calls = [

2753 mock.call(self.cifs_share.cmd_get_access(), True),

2754 ]

2755 self.assertEqual(2, len(ret))

2756 self.assertEqual(constants.CIFS_ACL_FULLCONTROL, ret['administrator'])

2757 self.assertEqual(constants.CIFS_ACL_FULLCONTROL, ret['guest'])

2758 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

2759

2760 def test_get_share_access_failed(self):

2761 expt_err = processutils.ProcessExecutionError(

2762 stdout=self.nfs_share.fake_output)

2763 self.ssh_hook.append(ex=expt_err)

2764

2765 context = self.manager.getStorageContext('CIFSShare')

2766 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

2767

2768 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

2769 context.get_share_access,

2770 mover_name=self.vdm.vdm_name,

2771 share_name=self.cifs_share.share_name)

2772

2773 ssh_calls = [

2774 mock.call(self.cifs_share.cmd_get_access(), True),

2775 ]

2776 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

2777

2778 def test_clear_share_access_has_white_list(self):

2779 self.ssh_hook.append(fakes.FakeData.cifs_access)

2780 self.ssh_hook.append('Command succeeded')

2781

2782 context = self.manager.getStorageContext('CIFSShare')

2783 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

2784

2785 to_remove = context.clear_share_access(

2786 mover_name=self.vdm.vdm_name,

2787 share_name=self.cifs_share.share_name,

2788 domain=self.cifs_server.domain_name,

2789 white_list_users=['guest'])

2790

2791 ssh_calls = [

2792 mock.call(self.cifs_share.cmd_get_access(), True),

2793 mock.call(self.cifs_share.cmd_change_access(action='revoke'),

2794 True),

2795 ]

2796 self.assertEqual({'administrator'}, to_remove)

2797 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

2798

2799

2800class NFSShareTestCase(StorageObjectTestCaseBase):

2801 def setUp(self):

2802 super(NFSShareTestCase, self).setUp()

2803 self.ssh_hook = utils.SSHSideEffect()

2804

2805 def test_create_nfs_share(self):

2806 self.ssh_hook.append(self.nfs_share.output_create())

2807

2808 context = self.manager.getStorageContext('NFSShare')

2809 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

2810

2811 context.create(name=self.nfs_share.share_name,

2812 mover_name=self.vdm.vdm_name)

2813

2814 ssh_calls = [mock.call(self.nfs_share.cmd_create(), True)]

2815 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

2816

2817 def test_create_nfs_share_with_error(self):

2818 expt_err = processutils.ProcessExecutionError(

2819 stdout=self.nfs_share.fake_output)

2820 self.ssh_hook.append(ex=expt_err)

2821

2822 context = self.manager.getStorageContext('NFSShare')

2823 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

2824

2825 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

2826 context.create,

2827 name=self.nfs_share.share_name,

2828 mover_name=self.vdm.vdm_name)

2829

2830 ssh_calls = [mock.call(self.nfs_share.cmd_create(), True)]

2831 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

2832

2833 def test_delete_nfs_share(self):

2834 self.ssh_hook.append(self.nfs_share.output_get_succeed(

2835 rw_hosts=self.nfs_share.rw_hosts,

2836 ro_hosts=self.nfs_share.ro_hosts))

2837 self.ssh_hook.append(self.nfs_share.output_delete_succeed())

2838

2839 context = self.manager.getStorageContext('NFSShare')

2840 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

2841

2842 context.delete(name=self.nfs_share.share_name,

2843 mover_name=self.vdm.vdm_name)

2844

2845 ssh_calls = [

2846 mock.call(self.nfs_share.cmd_get(), False),

2847 mock.call(self.nfs_share.cmd_delete(), True),

2848 ]

2849 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

2850

2851 def test_delete_nfs_share_not_found(self):

2852 expt_not_found = processutils.ProcessExecutionError(

2853 stdout=self.nfs_share.output_get_but_not_found())

2854 self.ssh_hook.append(ex=expt_not_found)

2855

2856 context = self.manager.getStorageContext('NFSShare')

2857 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

2858

2859 context.delete(name=self.nfs_share.share_name,

2860 mover_name=self.vdm.vdm_name)

2861

2862 ssh_calls = [mock.call(self.nfs_share.cmd_get(), False)]

2863 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

2864

2865 @mock.patch('time.sleep')

2866 def test_delete_nfs_share_locked(self, sleep_mock):

2867 self.ssh_hook.append(self.nfs_share.output_get_succeed(

2868 rw_hosts=self.nfs_share.rw_hosts,

2869 ro_hosts=self.nfs_share.ro_hosts))

2870 expt_locked = processutils.ProcessExecutionError(

2871 stdout=self.nfs_share.output_delete_but_locked())

2872 self.ssh_hook.append(ex=expt_locked)

2873 self.ssh_hook.append(self.nfs_share.output_delete_succeed())

2874

2875 context = self.manager.getStorageContext('NFSShare')

2876 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

2877

2878 context.delete(name=self.nfs_share.share_name,

2879 mover_name=self.vdm.vdm_name)

2880

2881 ssh_calls = [

2882 mock.call(self.nfs_share.cmd_get(), False),

2883 mock.call(self.nfs_share.cmd_delete(), True),

2884 mock.call(self.nfs_share.cmd_delete(), True),

2885 ]

2886 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

2887

2888 self.assertTrue(sleep_mock.called)

2889

2890 def test_delete_nfs_share_with_error(self):

2891 self.ssh_hook.append(self.nfs_share.output_get_succeed(

2892 rw_hosts=self.nfs_share.rw_hosts,

2893 ro_hosts=self.nfs_share.ro_hosts))

2894 expt_err = processutils.ProcessExecutionError(

2895 stdout=self.nfs_share.fake_output)

2896 self.ssh_hook.append(ex=expt_err)

2897

2898 context = self.manager.getStorageContext('NFSShare')

2899 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

2900

2901 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

2902 context.delete,

2903 name=self.nfs_share.share_name,

2904 mover_name=self.vdm.vdm_name)

2905

2906 ssh_calls = [

2907 mock.call(self.nfs_share.cmd_get(), False),

2908 mock.call(self.nfs_share.cmd_delete(), True),

2909 ]

2910 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

2911

2912 def test_get_nfs_share(self):

2913 self.ssh_hook.append(self.nfs_share.output_get_succeed(

2914 rw_hosts=self.nfs_share.rw_hosts,

2915 ro_hosts=self.nfs_share.ro_hosts))

2916

2917 context = self.manager.getStorageContext('NFSShare')

2918 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

2919

2920 context.get(name=self.nfs_share.share_name,

2921 mover_name=self.vdm.vdm_name)

2922

2923 # Get NFS share from cache

2924 context.get(name=self.nfs_share.share_name,

2925 mover_name=self.vdm.vdm_name)

2926

2927 ssh_calls = [mock.call(self.nfs_share.cmd_get(), False)]

2928 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

2929

2930 def test_get_nfs_share_not_found(self):

2931 expt_not_found = processutils.ProcessExecutionError(

2932 stdout=self.nfs_share.output_get_but_not_found())

2933 self.ssh_hook.append(ex=expt_not_found)

2934 self.ssh_hook.append(self.nfs_share.output_get_but_not_found())

2935

2936 context = self.manager.getStorageContext('NFSShare')

2937 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

2938

2939 context.get(name=self.nfs_share.share_name,

2940 mover_name=self.vdm.vdm_name)

2941

2942 context.get(name=self.nfs_share.share_name,

2943 mover_name=self.vdm.vdm_name)

2944

2945 ssh_calls = [

2946 mock.call(self.nfs_share.cmd_get(), False),

2947 mock.call(self.nfs_share.cmd_get(), False),

2948 ]

2949 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

2950

2951 def test_get_nfs_share_with_error(self):

2952 expt_err = processutils.ProcessExecutionError(

2953 stdout=self.nfs_share.fake_output)

2954 self.ssh_hook.append(ex=expt_err)

2955

2956 context = self.manager.getStorageContext('NFSShare')

2957 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

2958

2959 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

2960 context.get,

2961 name=self.nfs_share.share_name,

2962 mover_name=self.vdm.vdm_name)

2963

2964 ssh_calls = [mock.call(self.nfs_share.cmd_get(), False)]

2965 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

2966

2967 def test_allow_share_access(self):

2968 rw_hosts = copy.deepcopy(self.nfs_share.rw_hosts)

2969 rw_hosts.append(self.nfs_share.nfs_host_ip)

2970

2971 ro_hosts = copy.deepcopy(self.nfs_share.ro_hosts)

2972 ro_hosts.append(self.nfs_share.nfs_host_ip)

2973

2974 self.ssh_hook.append(self.nfs_share.output_get_succeed(

2975 rw_hosts=self.nfs_share.rw_hosts,

2976 ro_hosts=self.nfs_share.ro_hosts))

2977 self.ssh_hook.append(self.nfs_share.output_set_access_success())

2978 self.ssh_hook.append(self.nfs_share.output_get_succeed(

2979 rw_hosts=rw_hosts, ro_hosts=self.nfs_share.ro_hosts))

2980 self.ssh_hook.append(self.nfs_share.output_set_access_success())

2981 self.ssh_hook.append(self.nfs_share.output_get_succeed(

2982 rw_hosts=self.nfs_share.rw_hosts, ro_hosts=ro_hosts))

2983 self.ssh_hook.append(self.nfs_share.output_set_access_success())

2984 self.ssh_hook.append(self.nfs_share.output_get_succeed(

2985 rw_hosts=rw_hosts, ro_hosts=self.nfs_share.ro_hosts))

2986

2987 context = self.manager.getStorageContext('NFSShare')

2988 context.conn['SSH'].run_ssh = utils.EMCNFSShareMock(

2989 side_effect=self.ssh_hook)

2990

2991 context.allow_share_access(share_name=self.nfs_share.share_name,

2992 host_ip=self.nfs_share.nfs_host_ip,

2993 mover_name=self.vdm.vdm_name,

2994 access_level=const.ACCESS_LEVEL_RW)

2995

2996 context.allow_share_access(share_name=self.nfs_share.share_name,

2997 host_ip=self.nfs_share.nfs_host_ip,

2998 mover_name=self.vdm.vdm_name,

2999 access_level=const.ACCESS_LEVEL_RO)

3000

3001 context.allow_share_access(share_name=self.nfs_share.share_name,

3002 host_ip=self.nfs_share.nfs_host_ip,

3003 mover_name=self.vdm.vdm_name,

3004 access_level=const.ACCESS_LEVEL_RW)

3005

3006 context.allow_share_access(share_name=self.nfs_share.share_name,

3007 host_ip=self.nfs_share.nfs_host_ip,

3008 mover_name=self.vdm.vdm_name,

3009 access_level=const.ACCESS_LEVEL_RW)

3010

3011 ssh_calls = [

3012 mock.call(self.nfs_share.cmd_get()),

3013 mock.call(self.nfs_share.cmd_set_access(

3014 rw_hosts=rw_hosts, ro_hosts=self.nfs_share.ro_hosts)),

3015 mock.call(self.nfs_share.cmd_get()),

3016 mock.call(self.nfs_share.cmd_set_access(

3017 rw_hosts=self.nfs_share.rw_hosts, ro_hosts=ro_hosts)),

3018 mock.call(self.nfs_share.cmd_get()),

3019 mock.call(self.nfs_share.cmd_set_access(

3020 rw_hosts=rw_hosts, ro_hosts=self.nfs_share.ro_hosts)),

3021 mock.call(self.nfs_share.cmd_get()),

3022 ]

3023 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

3024

3025 def test_allow_share_access_not_found(self):

3026 expt_not_found = processutils.ProcessExecutionError(

3027 stdout=self.nfs_share.output_get_but_not_found())

3028 self.ssh_hook.append(ex=expt_not_found)

3029

3030 context = self.manager.getStorageContext('NFSShare')

3031 context.conn['SSH'].run_ssh = utils.EMCNFSShareMock(

3032 side_effect=self.ssh_hook)

3033

3034 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

3035 context.allow_share_access,

3036 share_name=self.nfs_share.share_name,

3037 host_ip=self.nfs_share.nfs_host_ip,

3038 mover_name=self.vdm.vdm_name,

3039 access_level=const.ACCESS_LEVEL_RW)

3040

3041 ssh_calls = [mock.call(self.nfs_share.cmd_get())]

3042 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

3043

3044 def test_deny_rw_share_access(self):

3045 rw_hosts = copy.deepcopy(self.nfs_share.rw_hosts)

3046 rw_hosts.append(self.nfs_share.nfs_host_ip)

3047

3048 self.ssh_hook.append(self.nfs_share.output_get_succeed(

3049 rw_hosts=rw_hosts, ro_hosts=self.nfs_share.ro_hosts))

3050 self.ssh_hook.append(self.nfs_share.output_set_access_success())

3051 self.ssh_hook.append(self.nfs_share.output_get_succeed(

3052 rw_hosts=self.nfs_share.rw_hosts,

3053 ro_hosts=self.nfs_share.ro_hosts))

3054

3055 context = self.manager.getStorageContext('NFSShare')

3056 context.conn['SSH'].run_ssh = utils.EMCNFSShareMock(

3057 side_effect=self.ssh_hook)

3058

3059 context.deny_share_access(share_name=self.nfs_share.share_name,

3060 host_ip=self.nfs_share.nfs_host_ip,

3061 mover_name=self.vdm.vdm_name)

3062

3063 ssh_calls = [

3064 mock.call(self.nfs_share.cmd_get()),

3065 mock.call(self.nfs_share.cmd_set_access(self.nfs_share.rw_hosts,

3066 self.nfs_share.ro_hosts)),

3067 mock.call(self.nfs_share.cmd_get()),

3068 ]

3069 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

3070

3071 def test_clear_share_access(self):

3072 hosts = ['192.168.1.1', '192.168.1.3']

3073

3074 self.ssh_hook.append(self.nfs_share.output_get_succeed(

3075 rw_hosts=self.nfs_share.rw_hosts,

3076 ro_hosts=self.nfs_share.ro_hosts))

3077 self.ssh_hook.append(self.nfs_share.output_set_access_success())

3078 self.ssh_hook.append(self.nfs_share.output_get_succeed(

3079 rw_hosts=[hosts[0]], ro_hosts=[hosts[1]]))

3080

3081 context = self.manager.getStorageContext('NFSShare')

3082 context.conn['SSH'].run_ssh = utils.EMCNFSShareMock(

3083 side_effect=self.ssh_hook)

3084

3085 context.clear_share_access(share_name=self.nfs_share.share_name,

3086 mover_name=self.vdm.vdm_name,

3087 white_list_hosts=hosts)

3088

3089 ssh_calls = [

3090 mock.call(self.nfs_share.cmd_get()),

3091 mock.call(self.nfs_share.cmd_set_access(

3092 rw_hosts=[hosts[0]], ro_hosts=[hosts[1]])),

3093 mock.call(self.nfs_share.cmd_get()),

3094 ]

3095 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

3096

3097 def test_deny_ro_share_access(self):

3098 ro_hosts = copy.deepcopy(self.nfs_share.ro_hosts)

3099 ro_hosts.append(self.nfs_share.nfs_host_ip)

3100

3101 self.ssh_hook.append(self.nfs_share.output_get_succeed(

3102 rw_hosts=self.nfs_share.rw_hosts, ro_hosts=ro_hosts))

3103 self.ssh_hook.append(self.nfs_share.output_set_access_success())

3104 self.ssh_hook.append(self.nfs_share.output_get_succeed(

3105 rw_hosts=self.nfs_share.rw_hosts,

3106 ro_hosts=self.nfs_share.ro_hosts))

3107

3108 context = self.manager.getStorageContext('NFSShare')

3109 context.conn['SSH'].run_ssh = utils.EMCNFSShareMock(

3110 side_effect=self.ssh_hook)

3111

3112 context.deny_share_access(share_name=self.nfs_share.share_name,

3113 host_ip=self.nfs_share.nfs_host_ip,

3114 mover_name=self.vdm.vdm_name)

3115

3116 context.deny_share_access(share_name=self.nfs_share.share_name,

3117 host_ip=self.nfs_share.nfs_host_ip,

3118 mover_name=self.vdm.vdm_name)

3119

3120 ssh_calls = [

3121 mock.call(self.nfs_share.cmd_get()),

3122 mock.call(self.nfs_share.cmd_set_access(self.nfs_share.rw_hosts,

3123 self.nfs_share.ro_hosts)),

3124 mock.call(self.nfs_share.cmd_get()),

3125 ]

3126 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

3127

3128 def test_deny_share_not_found(self):

3129 expt_not_found = processutils.ProcessExecutionError(

3130 stdout=self.nfs_share.output_get_but_not_found())

3131 self.ssh_hook.append(ex=expt_not_found)

3132

3133 context = self.manager.getStorageContext('NFSShare')

3134 context.conn['SSH'].run_ssh = utils.EMCNFSShareMock(

3135 side_effect=self.ssh_hook)

3136

3137 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

3138 context.deny_share_access,

3139 share_name=self.nfs_share.share_name,

3140 host_ip=self.nfs_share.nfs_host_ip,

3141 mover_name=self.vdm.vdm_name)

3142

3143 ssh_calls = [mock.call(self.nfs_share.cmd_get())]

3144 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

3145

3146 def test_deny_rw_share_with_error(self):

3147 rw_hosts = copy.deepcopy(self.nfs_share.rw_hosts)

3148 rw_hosts.append(self.nfs_share.nfs_host_ip)

3149

3150 self.ssh_hook.append(self.nfs_share.output_get_succeed(

3151 rw_hosts=rw_hosts, ro_hosts=self.nfs_share.ro_hosts))

3152 expt_not_found = processutils.ProcessExecutionError(

3153 stdout=self.nfs_share.output_get_but_not_found())

3154 self.ssh_hook.append(ex=expt_not_found)

3155

3156 context = self.manager.getStorageContext('NFSShare')

3157 context.conn['SSH'].run_ssh = utils.EMCNFSShareMock(

3158 side_effect=self.ssh_hook)

3159

3160 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

3161 context.deny_share_access,

3162 share_name=self.nfs_share.share_name,

3163 host_ip=self.nfs_share.nfs_host_ip,

3164 mover_name=self.vdm.vdm_name)

3165

3166 ssh_calls = [

3167 mock.call(self.nfs_share.cmd_get()),

3168 mock.call(self.nfs_share.cmd_set_access(self.nfs_share.rw_hosts,

3169 self.nfs_share.ro_hosts)),

3170 ]

3171 context.conn['SSH'].run_ssh.assert_has_calls(ssh_calls)

3172

3173 def test_clear_share_access_failed_to_get_share(self):

3174 self.ssh_hook.append("no output.")

3175

3176 context = self.manager.getStorageContext('NFSShare')

3177 context.conn['SSH'].run_ssh = mock.Mock(side_effect=self.ssh_hook)

3178

3179 self.assertRaises(exception.EMCPowerMaxXMLAPIError,

3180 context.clear_share_access,

3181 share_name=self.nfs_share.share_name,

3182 mover_name=self.vdm.vdm_name,

3183 white_list_hosts=None)

3184

3185 context.conn['SSH'].run_ssh.assert_called_once_with(

3186 self.nfs_share.cmd_get(), False)

Coverage for manila/tests/share/drivers/dell_emc/plugins/powermax/test_object_manager.py: 100%

1497 statements