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

1# Copyright 2014 NetApp 

2# All Rights Reserved. 

3# 

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

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

6# a copy of the License at 

7# 

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

9# 

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

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

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

13# License for the specific language governing permissions and limitations 

14# under the License. 

15 

16import copy 

17from unittest import mock 

18from urllib import parse 

19 

20import ddt 

21from oslo_db import exception as db_exception 

22from oslo_utils import timeutils 

23from webob import exc as webob_exc 

24 

25from manila.api import common 

26from manila.api.openstack import api_version_request as api_version 

27from manila.api.v2 import share_networks 

28from manila.db import api as db_api 

29from manila import exception 

30from manila import quota 

31from manila.share import api as share_api 

32from manila import test 

33from manila.tests.api import fakes 

34from manila.tests import db_utils 

35 

36 

37fake_share_network_subnet = { 

38 'id': 'fake subnet id', 

39 'neutron_net_id': 'fake net id', 

40 'neutron_subnet_id': 'fake subnet id', 

41 'network_type': 'vlan', 

42 'segmentation_id': 1000, 

43 'cidr': '10.0.0.0/24', 

44 'ip_version': 4, 

45 'share_network_id': 'fake network id', 

46 'availability_zone_id': None, 

47 'share_servers': [], 

48 'availability_zone': [] 

49} 

50 

51fake_share_network = { 

52 'id': 'fake network id', 

53 'project_id': 'fake project', 

54 'created_at': timeutils.parse_strtime('2002-02-02', fmt="%Y-%m-%d"), 

55 'updated_at': None, 

56 'name': 'fake name', 

57 'description': 'fake description', 

58 'security_services': [], 

59 'share_network_subnets': [], 

60 'security_service_update_support': True, 

61 'status': 'active' 

62} 

63 

64 

65fake_share_network_shortened = { 

66 'id': 'fake network id', 

67 'name': 'fake name', 

68} 

69 

70fake_share_network_with_ss = { 

71 'id': 'sn-id', 

72 'project_id': 'fake', 

73 'created_at': timeutils.parse_strtime('2001-01-01', fmt="%Y-%m-%d"), 

74 'updated_at': None, 

75 'name': 'test-sn', 

76 'description': 'fake description', 

77 'share_network_subnets': [], 

78 'security_services': [{'id': 'fake-ss-id'}] 

79} 

80 

81fake_sn_with_ss_shortened = { 

82 'id': 'sn-id', 

83 'name': 'test-sn', 

84} 

85 

86ADD_UPDATE_SEC_SERVICE_VERSION = '2.63' 

87 

88QUOTAS = quota.QUOTAS 

89 

90 

91@ddt.ddt 

92class ShareNetworkAPITest(test.TestCase): 

93 

94 def setUp(self): 

95 super(ShareNetworkAPITest, self).setUp() 

96 self.controller = share_networks.ShareNetworkController() 

97 self.req = fakes.HTTPRequest.blank('/share-networks') 

98 self.body = {share_networks.RESOURCE_NAME: {'name': 'fake name'}} 

99 self.context = self.req.environ['manila.context'] 

100 self.share_api = share_api.API() 

101 

102 def _check_share_network_view_shortened(self, view, share_nw): 

103 self.assertEqual(share_nw['id'], view['id']) 

104 self.assertEqual(share_nw['name'], view['name']) 

105 

106 def _check_share_network_view(self, view, share_nw): 

107 self.assertEqual(share_nw['id'], view['id']) 

108 self.assertEqual(share_nw['project_id'], view['project_id']) 

109 self.assertEqual(share_nw['created_at'], view['created_at']) 

110 self.assertEqual(share_nw['updated_at'], view['updated_at']) 

111 self.assertEqual(share_nw['name'], view['name']) 

112 self.assertEqual(share_nw['description'], view['description']) 

113 self.assertNotIn('shares', view) 

114 self.assertNotIn('network_allocations', view) 

115 self.assertNotIn('security_services', view) 

116 

117 def _setup_body_for_create_test(self, data): 

118 data.update({'user_id': 'fake_user_id'}) 

119 body = {share_networks.RESOURCE_NAME: data} 

120 return body 

121 

122 @ddt.data( 

123 {'neutron_net_id': 'fake', 'neutron_subnet_id': 'fake'}) 

124 def test_create_valid_cases(self, data): 

125 body = self._setup_body_for_create_test(data) 

126 result = self.controller.create(self.req, body) 

127 data.pop('user_id', None) 

128 for k, v in data.items(): 

129 self.assertIn(data[k], result['share_network'][k]) 

130 

131 @ddt.data( 

132 {'neutron_net_id': 'fake', 'neutron_subnet_id': 'fake', 

133 'availability_zone': 'fake'}) 

134 def test_create_valid_cases_upper_2_50(self, data): 

135 req = fakes.HTTPRequest.blank('/share-networks', version="2.51") 

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

137 body = self._setup_body_for_create_test(data) 

138 fake_az = { 

139 'name': 'fake', 

140 'id': 'fake_id' 

141 } 

142 self.mock_object(db_api, 'availability_zone_get', 

143 mock.Mock(return_value=fake_az)) 

144 

145 result = self.controller.create(req, body) 

146 result_subnet = result['share_network']['share_network_subnets'][0] 

147 data.pop('user_id', None) 

148 data.pop('project_id', None) 

149 data.pop('availability_zone_id', None) 

150 data.pop('id', None) 

151 data['availability_zone'] = result_subnet['availability_zone'] 

152 

153 for k, v in data.items(): 

154 self.assertIn(k, result_subnet.keys()) 

155 

156 db_api.availability_zone_get.assert_called_once_with( 

157 context, fake_az['name'] 

158 ) 

159 

160 @ddt.data( 

161 {'nova_net_id': 'foo', 'neutron_net_id': 'bar'}, 

162 {'nova_net_id': 'foo', 'neutron_subnet_id': 'quuz'}, 

163 {'nova_net_id': 'foo', 'neutron_net_id': 'bar', 

164 'neutron_subnet_id': 'quuz'}, 

165 {'nova_net_id': 'fake_nova_net_id'}, 

166 {'neutron_net_id': 'bar'}, 

167 {'neutron_subnet_id': 'quuz'}) 

168 def test_create_invalid_cases(self, data): 

169 data.update({'user_id': 'fake_user_id'}) 

170 body = {share_networks.RESOURCE_NAME: data} 

171 self.assertRaises( 

172 webob_exc.HTTPBadRequest, self.controller.create, self.req, body) 

173 

174 @ddt.data( 

175 {'name': 'new fake name'}, 

176 {'description': 'new fake description'}, 

177 {'name': 'new fake name', 'description': 'new fake description'}) 

178 def test_update_valid_cases(self, data): 

179 body = {share_networks.RESOURCE_NAME: {'user_id': 'fake_user'}} 

180 created = self.controller.create(self.req, body) 

181 

182 body = {share_networks.RESOURCE_NAME: data} 

183 result = self.controller.update( 

184 self.req, created['share_network']['id'], body) 

185 

186 for k, v in data.items(): 

187 self.assertIn(data[k], result['share_network'][k]) 

188 

189 self._check_share_network_view( 

190 result[share_networks.RESOURCE_NAME], 

191 result['share_network']) 

192 

193 @ddt.data( 

194 {'nova_net_id': 'foo', 'neutron_net_id': 'bar'}, 

195 {'nova_net_id': 'foo', 'neutron_subnet_id': 'quuz'}, 

196 {'nova_net_id': 'foo', 'neutron_net_id': 'bar', 

197 'neutron_subnet_id': 'quuz'}, 

198 {'nova_net_id': 'fake_nova_net_id'}, 

199 ) 

200 def test_update_invalid_cases(self, data): 

201 body = {share_networks.RESOURCE_NAME: {'user_id': 'fake_user'}} 

202 created = self.controller.create(self.req, body) 

203 body = {share_networks.RESOURCE_NAME: data} 

204 self.assertRaises( 

205 webob_exc.HTTPBadRequest, 

206 self.controller.update, 

207 self.req, created['share_network']['id'], body) 

208 

209 @ddt.data( 

210 ({'share_network_subnets': [ 

211 {'share_network_id': fake_share_network['id']}]}, True), 

212 ({'share_network_subnets': []}, False)) 

213 @ddt.unpack 

214 def test__subnet_has_search_opt(self, network, has_search_opt): 

215 search_opts = { 

216 'share_network_id': fake_share_network['id'] 

217 } 

218 

219 result = None 

220 

221 for key, value in search_opts.items(): 

222 result = self.controller._subnet_has_search_opt( 

223 key, value, network) 

224 

225 self.assertEqual(has_search_opt, result) 

226 

227 def test_create_nominal(self): 

228 self.mock_object(db_api, 'share_network_subnet_create') 

229 self.mock_object(db_api, 'share_network_get', 

230 mock.Mock(return_value=fake_share_network)) 

231 self.mock_object(common, 'check_net_id_and_subnet_id') 

232 with mock.patch.object(db_api, 

233 'share_network_create', 

234 mock.Mock(return_value=fake_share_network)): 

235 

236 result = self.controller.create(self.req, self.body) 

237 

238 db_api.share_network_create.assert_called_once_with( 

239 self.req.environ['manila.context'], 

240 self.body[share_networks.RESOURCE_NAME]) 

241 

242 self._check_share_network_view( 

243 result[share_networks.RESOURCE_NAME], 

244 fake_share_network) 

245 

246 def test_create_db_api_exception(self): 

247 with mock.patch.object(db_api, 

248 'share_network_create', 

249 mock.Mock(side_effect=db_exception.DBError)): 

250 self.assertRaises(webob_exc.HTTPInternalServerError, 

251 self.controller.create, 

252 self.req, 

253 self.body) 

254 

255 def test_create_wrong_body(self): 

256 body = None 

257 self.assertRaises(webob_exc.HTTPUnprocessableEntity, 

258 self.controller.create, 

259 self.req, 

260 body) 

261 

262 @ddt.data( 

263 {'availability_zone': 'fake-zone'}) 

264 def test_create_az_not_found(self, data): 

265 req = fakes.HTTPRequest.blank('/share-networks', version="2.51") 

266 

267 self.mock_object( 

268 db_api, 'availability_zone_get', 

269 mock.Mock( 

270 side_effect=exception.AvailabilityZoneNotFound(id='fake'))) 

271 

272 body = {share_networks.RESOURCE_NAME: data} 

273 

274 self.assertRaises(webob_exc.HTTPBadRequest, 

275 self.controller.create, 

276 req, 

277 body) 

278 

279 def test_create_error_on_network_creation(self): 

280 self.mock_object(share_networks.QUOTAS, 'reserve', 

281 mock.Mock(return_value='fake_reservation')) 

282 self.mock_object(share_networks.QUOTAS, 'rollback') 

283 self.mock_object(db_api, 'share_network_create', 

284 mock.Mock(side_effect=db_exception.DBError())) 

285 

286 self.assertRaises(webob_exc.HTTPInternalServerError, 

287 self.controller.create, 

288 self.req, 

289 self.body) 

290 self.assertTrue(share_networks.QUOTAS.rollback.called) 

291 

292 def test_create_error_on_subnet_creation(self): 

293 data = { 

294 'neutron_net_id': 'fake', 

295 'neutron_subnet_id': 'fake', 

296 'id': fake_share_network['id'] 

297 } 

298 subnet_data = copy.deepcopy(data) 

299 self.mock_object(share_networks.QUOTAS, 'reserve', 

300 mock.Mock(return_value='fake_reservation')) 

301 self.mock_object(share_networks.QUOTAS, 'rollback') 

302 self.mock_object(db_api, 'share_network_create', 

303 mock.Mock(return_value=fake_share_network)) 

304 self.mock_object(db_api, 'share_network_subnet_create', 

305 mock.Mock(side_effect=db_exception.DBError())) 

306 self.mock_object(db_api, 'share_network_delete') 

307 body = {share_networks.RESOURCE_NAME: data} 

308 

309 self.assertRaises(webob_exc.HTTPInternalServerError, 

310 self.controller.create, 

311 self.req, 

312 body) 

313 

314 db_api.share_network_create.assert_called_once_with(self.context, data) 

315 subnet_data['share_network_id'] = data['id'] 

316 subnet_data.pop('id') 

317 db_api.share_network_subnet_create.assert_called_once_with( 

318 self.context, subnet_data) 

319 db_api.share_network_delete.assert_called_once_with( 

320 self.context, fake_share_network['id']) 

321 self.assertTrue(share_networks.QUOTAS.rollback.called) 

322 

323 def test_delete_nominal(self): 

324 share_nw = fake_share_network.copy() 

325 subnet = fake_share_network_subnet.copy() 

326 subnet['share_servers'] = ['foo', 'bar'] 

327 share_nw['share_network_subnets'] = [subnet] 

328 self.mock_object(db_api, 'share_network_get', 

329 mock.Mock(return_value=share_nw)) 

330 self.mock_object(db_api, 'share_instance_get_all_by_share_network', 

331 mock.Mock(return_value=[])) 

332 self.mock_object(self.controller.share_rpcapi, 'delete_share_server') 

333 self.mock_object(self.controller, 

334 '_all_share_servers_are_auto_deletable', 

335 mock.Mock(return_value=True)) 

336 self.mock_object(db_api, 'share_network_delete') 

337 

338 self.controller.delete(self.req, share_nw['id']) 

339 

340 db_api.share_network_get.assert_called_once_with( 

341 self.req.environ['manila.context'], share_nw['id']) 

342 (db_api.share_instance_get_all_by_share_network. 

343 assert_called_once_with(self.req.environ['manila.context'], 

344 share_nw['id'])) 

345 self.controller.share_rpcapi.delete_share_server.assert_has_calls([ 

346 mock.call(self.req.environ['manila.context'], 'foo'), 

347 mock.call(self.req.environ['manila.context'], 'bar')]) 

348 db_api.share_network_delete.assert_called_once_with( 

349 self.req.environ['manila.context'], share_nw['id']) 

350 

351 def test_delete_not_found(self): 

352 share_nw = 'fake network id' 

353 self.mock_object(db_api, 'share_network_get', 

354 mock.Mock(side_effect=exception.ShareNetworkNotFound( 

355 share_network_id=share_nw))) 

356 

357 self.assertRaises(webob_exc.HTTPNotFound, 

358 self.controller.delete, 

359 self.req, 

360 share_nw) 

361 

362 def test_quota_delete_reservation_failed(self): 

363 share_nw = fake_share_network.copy() 

364 subnet = fake_share_network_subnet.copy() 

365 subnet['share_servers'] = ['foo', 'bar'] 

366 share_nw['share_network_subnets'] = [subnet] 

367 share_nw['user_id'] = 'fake_user_id' 

368 

369 self.mock_object(db_api, 'share_network_get', 

370 mock.Mock(return_value=share_nw)) 

371 self.mock_object(db_api, 'share_instance_get_all_by_share_network', 

372 mock.Mock(return_value=[])) 

373 self.mock_object(self.controller, 

374 '_all_share_servers_are_auto_deletable', 

375 mock.Mock(return_value=True)) 

376 self.mock_object(self.controller.share_rpcapi, 'delete_share_server') 

377 self.mock_object(db_api, 'share_network_delete') 

378 self.mock_object(share_networks.QUOTAS, 'reserve', 

379 mock.Mock(side_effect=Exception)) 

380 self.mock_object(share_networks.QUOTAS, 'commit') 

381 

382 self.controller.delete(self.req, share_nw['id']) 

383 

384 db_api.share_network_get.assert_called_once_with( 

385 self.req.environ['manila.context'], share_nw['id']) 

386 

387 (db_api.share_instance_get_all_by_share_network. 

388 assert_called_once_with(self.req.environ['manila.context'], 

389 share_nw['id'])) 

390 

391 self.controller.share_rpcapi.delete_share_server.assert_has_calls([ 

392 mock.call(self.req.environ['manila.context'], 'foo'), 

393 mock.call(self.req.environ['manila.context'], 'bar')]) 

394 db_api.share_network_delete.assert_called_once_with( 

395 self.req.environ['manila.context'], share_nw['id']) 

396 share_networks.QUOTAS.reserve.assert_called_once_with( 

397 self.req.environ['manila.context'], 

398 project_id=share_nw['project_id'], 

399 share_networks=-1, 

400 user_id=share_nw['user_id'] 

401 ) 

402 self.assertFalse(share_networks.QUOTAS.commit.called) 

403 

404 def test_delete_in_use_by_share(self): 

405 share_nw = fake_share_network.copy() 

406 self.mock_object(db_api, 'share_network_get', 

407 mock.Mock(return_value=share_nw)) 

408 self.mock_object(db_api, 'share_instance_get_all_by_share_network', 

409 mock.Mock(return_value=['foo', 'bar'])) 

410 

411 self.assertRaises(webob_exc.HTTPConflict, 

412 self.controller.delete, 

413 self.req, 

414 share_nw['id']) 

415 

416 db_api.share_network_get.assert_called_once_with( 

417 self.req.environ['manila.context'], share_nw['id']) 

418 (db_api.share_instance_get_all_by_share_network. 

419 assert_called_once_with(self.req.environ['manila.context'], 

420 share_nw['id'])) 

421 

422 def test_delete_in_use_by_share_group(self): 

423 share_nw = fake_share_network.copy() 

424 self.mock_object(db_api, 'share_network_get', 

425 mock.Mock(return_value=share_nw)) 

426 self.mock_object(db_api, 'count_share_groups_in_share_network', 

427 mock.Mock(return_value=2)) 

428 

429 self.assertRaises(webob_exc.HTTPConflict, 

430 self.controller.delete, 

431 self.req, 

432 share_nw['id']) 

433 

434 db_api.share_network_get.assert_called_once_with( 

435 self.req.environ['manila.context'], share_nw['id']) 

436 

437 def test_delete_contains_is_auto_deletable_false_servers(self): 

438 share_nw = fake_share_network.copy() 

439 self.mock_object(db_api, 'share_network_get', 

440 mock.Mock(return_value=share_nw)) 

441 self.mock_object(db_api, 'count_share_groups_in_share_network') 

442 self.mock_object(share_networks.ShareNetworkController, 

443 '_all_share_servers_are_auto_deletable', 

444 mock.Mock(return_value=False)) 

445 

446 self.assertRaises(webob_exc.HTTPConflict, 

447 self.controller.delete, 

448 self.req, 

449 share_nw['id']) 

450 

451 db_api.share_network_get.assert_called_once_with( 

452 self.req.environ['manila.context'], share_nw['id']) 

453 

454 def test_delete_contains_more_than_one_subnet(self): 

455 share_nw = fake_share_network.copy() 

456 self.mock_object(db_api, 'share_network_get', 

457 mock.Mock(return_value=share_nw)) 

458 self.mock_object(db_api, 'share_instance_get_all_by_share_network', 

459 mock.Mock(return_value=None)) 

460 self.mock_object(db_api, 'count_share_groups_in_share_network', 

461 mock.Mock(return_value=None)) 

462 self.mock_object(self.controller, '_share_network_contains_subnets', 

463 mock.Mock(return_value=True)) 

464 

465 self.assertRaises(webob_exc.HTTPConflict, 

466 self.controller.delete, 

467 self.req, 

468 share_nw['id']) 

469 

470 db_api.share_network_get.assert_called_once_with( 

471 self.context, share_nw['id']) 

472 (db_api.share_instance_get_all_by_share_network 

473 .assert_called_once_with(self.context, share_nw['id'])) 

474 db_api.count_share_groups_in_share_network.assert_called_once_with( 

475 self.context, share_nw['id'] 

476 ) 

477 (self.controller._share_network_contains_subnets 

478 .assert_called_once_with(share_nw)) 

479 

480 def test_delete_subnet_contains_share_server(self): 

481 share_nw = fake_share_network.copy() 

482 share_nw['share_network_subnets'].append({ 

483 'id': 'fake_sns_id', 

484 'share_servers': [{'id': 'fake_share_server_id'}] 

485 }) 

486 self.mock_object(db_api, 'share_network_get', 

487 mock.Mock(return_value=share_nw)) 

488 self.mock_object(db_api, 'count_share_groups_in_share_network', 

489 mock.Mock(return_value=0)) 

490 self.mock_object(self.controller, '_share_network_contains_subnets', 

491 mock.Mock(return_value=False)) 

492 self.mock_object( 

493 self.controller, '_all_share_servers_are_auto_deletable', 

494 mock.Mock(return_value=False)) 

495 

496 self.assertRaises(webob_exc.HTTPConflict, 

497 self.controller.delete, 

498 self.req, 

499 share_nw['id']) 

500 

501 @ddt.data( 

502 ({'share_servers': [{'is_auto_deletable': True}, 

503 {'is_auto_deletable': True}]}, True), 

504 ({'share_servers': [{'is_auto_deletable': True}, 

505 {'is_auto_deletable': False}]}, False), 

506 ) 

507 @ddt.unpack 

508 def test__share_servers_are_auto_deletable(self, fake_share_network, 

509 expected_result): 

510 self.assertEqual( 

511 expected_result, 

512 self.controller._all_share_servers_are_auto_deletable( 

513 fake_share_network)) 

514 

515 @ddt.data( 

516 ({'share_network_subnets': [{'share_servers': [{}, {}]}]}, True), 

517 ({'share_network_subnets': [{'share_servers': []}]}, False), 

518 ) 

519 @ddt.unpack 

520 def test__share_network_subnets_contain_share_servers(self, share_network, 

521 expected_result): 

522 self.assertEqual( 

523 expected_result, 

524 self.controller._share_network_subnets_contain_share_servers( 

525 share_network)) 

526 

527 def test_show_nominal(self): 

528 share_nw = 'fake network id' 

529 with mock.patch.object(db_api, 

530 'share_network_get', 

531 mock.Mock(return_value=fake_share_network)): 

532 result = self.controller.show(self.req, share_nw) 

533 

534 db_api.share_network_get.assert_called_once_with( 

535 self.req.environ['manila.context'], 

536 share_nw) 

537 

538 self._check_share_network_view( 

539 result[share_networks.RESOURCE_NAME], 

540 fake_share_network) 

541 

542 def test_show_not_found(self): 

543 share_nw = 'fake network id' 

544 test_exception = exception.ShareNetworkNotFound( 

545 share_network_id=share_nw) 

546 with mock.patch.object(db_api, 

547 'share_network_get', 

548 mock.Mock(side_effect=test_exception)): 

549 self.assertRaises(webob_exc.HTTPNotFound, 

550 self.controller.show, 

551 self.req, 

552 share_nw) 

553 

554 def test_index_no_filters(self): 

555 networks = [fake_share_network] 

556 with mock.patch.object(db_api, 

557 'share_network_get_all_by_filter', 

558 mock.Mock(return_value=networks)): 

559 

560 result = self.controller.index(self.req) 

561 

562 db_api.share_network_get_all_by_filter.assert_called_once_with( 

563 self.context, filters={}) 

564 

565 self.assertEqual(1, len(result[share_networks.RESOURCES_NAME])) 

566 self._check_share_network_view_shortened( 

567 result[share_networks.RESOURCES_NAME][0], 

568 fake_share_network_shortened) 

569 

570 def test_index_detailed(self): 

571 networks = [fake_share_network] 

572 with mock.patch.object(db_api, 

573 'share_network_get_all_by_filter', 

574 mock.Mock(return_value=networks)): 

575 

576 result = self.controller.detail(self.req) 

577 

578 db_api.share_network_get_all_by_filter.assert_called_once_with( 

579 self.context, filters={}) 

580 

581 self.assertEqual(1, len(result[share_networks.RESOURCES_NAME])) 

582 self._check_share_network_view( 

583 result[share_networks.RESOURCES_NAME][0], 

584 fake_share_network) 

585 

586 @mock.patch.object(db_api, 'share_network_get_all_by_filter', 

587 mock.Mock()) 

588 def test_index_filter_by_security_service(self): 

589 db_api.share_network_get_all_by_filter.return_value = [ 

590 fake_share_network_with_ss] 

591 req = fakes.HTTPRequest.blank( 

592 '/share_networks?security_service_id=fake-ss-id') 

593 result = self.controller.index(req) 

594 filters = {'security_service_id': 'fake-ss-id'} 

595 (db_api.share_network_get_all_by_filter. 

596 assert_called_once_with(req.environ['manila.context'], 

597 filters=filters)) 

598 self.assertEqual(1, len(result[share_networks.RESOURCES_NAME])) 

599 self._check_share_network_view_shortened( 

600 result[share_networks.RESOURCES_NAME][0], 

601 fake_sn_with_ss_shortened) 

602 

603 @mock.patch.object(db_api, 'share_network_get_all_by_filter', mock.Mock()) 

604 def test_index_all_tenants_non_admin_context(self): 

605 req = fakes.HTTPRequest.blank( 

606 '/share_networks?all_tenants=1') 

607 fake_context = req.environ['manila.context'] 

608 db_api.share_network_get_all_by_filter.return_value = [] 

609 self.controller.index(req) 

610 db_api.share_network_get_all_by_filter.assert_called_with( 

611 fake_context, filters={}) 

612 

613 @mock.patch.object(db_api, 'share_network_get_all_by_filter', mock.Mock()) 

614 def test_index_all_tenants_admin_context(self): 

615 db_api.share_network_get_all_by_filter.return_value = [ 

616 fake_share_network] 

617 req = fakes.HTTPRequest.blank( 

618 '/share_networks?all_tenants=1', 

619 use_admin_context=True) 

620 result = self.controller.index(req) 

621 db_api.share_network_get_all_by_filter.assert_called_once_with( 

622 req.environ['manila.context'], filters={}) 

623 self.assertEqual(1, len(result[share_networks.RESOURCES_NAME])) 

624 self._check_share_network_view_shortened( 

625 result[share_networks.RESOURCES_NAME][0], 

626 fake_share_network_shortened) 

627 

628 @mock.patch.object(db_api, 'share_network_get_all', mock.Mock()) 

629 def test_index_all_tenants_with_invaild_value(self): 

630 req = fakes.HTTPRequest.blank( 

631 '/share_networks?all_tenants=wonk', 

632 use_admin_context=True) 

633 

634 self.assertRaises(exception.InvalidInput, self.controller.index, req) 

635 

636 @mock.patch.object(db_api, 'share_network_get_all_by_filter', mock.Mock()) 

637 def test_index_all_tenants_with_value_zero(self): 

638 db_api.share_network_get_all_by_filter.return_value = [ 

639 fake_share_network] 

640 req = fakes.HTTPRequest.blank( 

641 '/share_networks?all_tenants=0', 

642 use_admin_context=True) 

643 

644 result = self.controller.index(req) 

645 

646 self.assertEqual(1, len(result[share_networks.RESOURCES_NAME])) 

647 self._check_share_network_view_shortened( 

648 result[share_networks.RESOURCES_NAME][0], 

649 fake_share_network_shortened) 

650 filters = {'project_id': 'fake'} 

651 db_api.share_network_get_all_by_filter.assert_called_once_with( 

652 req.environ['manila.context'], filters=filters) 

653 

654 @mock.patch.object(db_api, 'share_network_get_all_by_filter', mock.Mock()) 

655 def test_index_filter_by_project_id_non_admin_context(self): 

656 req = fakes.HTTPRequest.blank( 

657 '/share_networks?project_id=fake project') 

658 fake_context = req.environ['manila.context'] 

659 db_api.share_network_get_all_by_filter.return_value = [] 

660 self.controller.index(req) 

661 db_api.share_network_get_all_by_filter.assert_called_with( 

662 fake_context, filters={}) 

663 

664 @mock.patch.object(db_api, 'share_network_get_all_by_filter', mock.Mock()) 

665 def test_index_filter_by_project_id_admin_context(self): 

666 db_api.share_network_get_all_by_filter.return_value = [ 

667 fake_share_network_with_ss 

668 ] 

669 req = fakes.HTTPRequest.blank( 

670 '/share_networks?project_id=fake', 

671 use_admin_context=True) 

672 result = self.controller.index(req) 

673 filters = {'project_id': 'fake'} 

674 db_api.share_network_get_all_by_filter.assert_called_once_with( 

675 req.environ['manila.context'], filters=filters) 

676 self.assertEqual(1, len(result[share_networks.RESOURCES_NAME])) 

677 self._check_share_network_view_shortened( 

678 result[share_networks.RESOURCES_NAME][0], 

679 fake_sn_with_ss_shortened) 

680 

681 @mock.patch.object(db_api, 'share_network_get_all_by_filter', 

682 mock.Mock()) 

683 def test_index_filter_by_ss_and_project_id_admin_context(self): 

684 db_api.share_network_get_all_by_filter.return_value = [ 

685 fake_share_network_with_ss 

686 ] 

687 req = fakes.HTTPRequest.blank( 

688 '/share_networks?security_service_id=fake-ss-id&project_id=fake', 

689 use_admin_context=True) 

690 result = self.controller.index(req) 

691 filters = {'project_id': 'fake', 

692 'security_service_id': 'fake-ss-id'} 

693 db_api.share_network_get_all_by_filter.assert_called_once_with( 

694 req.environ['manila.context'], filters=filters) 

695 self.assertEqual(1, len(result[share_networks.RESOURCES_NAME])) 

696 self._check_share_network_view_shortened( 

697 result[share_networks.RESOURCES_NAME][0], 

698 fake_sn_with_ss_shortened) 

699 

700 @ddt.data(('name=fo', 0), ('description=d', 0), 

701 ('name=foo&description=d', 0), 

702 ('name=foo', 1), ('description=ds', 1), 

703 ('name~=foo&description~=ds', 2), 

704 ('name=foo&description~=ds', 1), 

705 ('name~=foo&description=ds', 1)) 

706 @ddt.unpack 

707 @mock.patch.object(db_api, 'share_network_get_all_by_filter', 

708 mock.Mock()) 

709 def test_index_filter_by_name_and_description( 

710 self, filter, share_network_number): 

711 fake_objs = [{'name': 'fo2', 'description': 'd2', 'id': 'fake1'}, 

712 {'name': 'foo', 'description': 'ds', 'id': 'fake2'}, 

713 {'name': 'foo1', 'description': 'ds1', 'id': 'fake3'}] 

714 db_api.share_network_get_all_by_filter.return_value = fake_objs 

715 req = fakes.HTTPRequest.blank( 

716 '/share_networks?' + filter,