blob: b2007619b1b6cfd23c6bf63f4dd9a2b3ca81e18d [file] [log] [blame]
Daniel Mellado3c0aeab2016-01-29 11:30:25 +00001# Copyright 2012 OpenStack Foundation
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
Ihar Hrachyshka59382252016-04-05 15:54:33 +020016import functools
Ihar Hrachyshkaaeb03a02016-05-18 20:03:18 +020017import math
Ihar Hrachyshka59382252016-04-05 15:54:33 +020018
Daniel Mellado3c0aeab2016-01-29 11:30:25 +000019import netaddr
Chandan Kumarc125fd12017-11-15 19:41:01 +053020from neutron_lib import constants as const
21from tempest.common import utils as tutils
Daniel Mellado3c0aeab2016-01-29 11:30:25 +000022from tempest.lib.common.utils import data_utils
23from tempest.lib import exceptions as lib_exc
24from tempest import test
25
Chandan Kumar667d3d32017-09-22 12:24:06 +053026from neutron_tempest_plugin.api import clients
27from neutron_tempest_plugin.common import constants
28from neutron_tempest_plugin.common import utils
29from neutron_tempest_plugin import config
30from neutron_tempest_plugin import exceptions
Daniel Mellado3c0aeab2016-01-29 11:30:25 +000031
32CONF = config.CONF
33
34
35class BaseNetworkTest(test.BaseTestCase):
36
Brian Haleyae328b92018-10-09 19:51:54 -040037 """Base class for Neutron tests that use the Tempest Neutron REST client
Daniel Mellado3c0aeab2016-01-29 11:30:25 +000038
39 Per the Neutron API Guide, API v1.x was removed from the source code tree
40 (docs.openstack.org/api/openstack-network/2.0/content/Overview-d1e71.html)
41 Therefore, v2.x of the Neutron API is assumed. It is also assumed that the
42 following options are defined in the [network] section of etc/tempest.conf:
43
44 project_network_cidr with a block of cidr's from which smaller blocks
45 can be allocated for tenant networks
46
47 project_network_mask_bits with the mask bits to be used to partition
48 the block defined by tenant-network_cidr
49
50 Finally, it is assumed that the following option is defined in the
51 [service_available] section of etc/tempest.conf
52
53 neutron as True
54 """
55
56 force_tenant_isolation = False
57 credentials = ['primary']
58
59 # Default to ipv4.
Federico Ressi0ddc93b2018-04-09 12:01:48 +020060 _ip_version = const.IP_VERSION_4
Daniel Mellado3c0aeab2016-01-29 11:30:25 +000061
Federico Ressi61b564e2018-07-06 08:10:31 +020062 # Derive from BaseAdminNetworkTest class to have this initialized
63 admin_client = None
64
Federico Ressia69dcd52018-07-06 09:45:34 +020065 external_network_id = CONF.network.public_network_id
66
Daniel Mellado3c0aeab2016-01-29 11:30:25 +000067 @classmethod
68 def get_client_manager(cls, credential_type=None, roles=None,
69 force_new=None):
Genadi Chereshnyacc395c02016-07-25 12:17:37 +030070 manager = super(BaseNetworkTest, cls).get_client_manager(
71 credential_type=credential_type,
72 roles=roles,
73 force_new=force_new
74 )
Daniel Mellado3c0aeab2016-01-29 11:30:25 +000075 # Neutron uses a different clients manager than the one in the Tempest
Jens Harbott860b46a2017-11-15 21:23:15 +000076 # save the original in case mixed tests need it
77 if credential_type == 'primary':
78 cls.os_tempest = manager
Daniel Mellado3c0aeab2016-01-29 11:30:25 +000079 return clients.Manager(manager.credentials)
80
81 @classmethod
82 def skip_checks(cls):
83 super(BaseNetworkTest, cls).skip_checks()
84 if not CONF.service_available.neutron:
85 raise cls.skipException("Neutron support is required")
Federico Ressi0ddc93b2018-04-09 12:01:48 +020086 if (cls._ip_version == const.IP_VERSION_6 and
87 not CONF.network_feature_enabled.ipv6):
Daniel Mellado3c0aeab2016-01-29 11:30:25 +000088 raise cls.skipException("IPv6 Tests are disabled.")
Jakub Libosvar1982aa12017-05-30 11:15:33 +000089 for req_ext in getattr(cls, 'required_extensions', []):
Chandan Kumarc125fd12017-11-15 19:41:01 +053090 if not tutils.is_extension_enabled(req_ext, 'network'):
Jakub Libosvar1982aa12017-05-30 11:15:33 +000091 msg = "%s extension not enabled." % req_ext
92 raise cls.skipException(msg)
Daniel Mellado3c0aeab2016-01-29 11:30:25 +000093
94 @classmethod
95 def setup_credentials(cls):
96 # Create no network resources for these test.
97 cls.set_network_resources()
98 super(BaseNetworkTest, cls).setup_credentials()
99
100 @classmethod
101 def setup_clients(cls):
102 super(BaseNetworkTest, cls).setup_clients()
fumihiko kakumaa216fc12017-07-14 10:43:29 +0900103 cls.client = cls.os_primary.network_client
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000104
105 @classmethod
106 def resource_setup(cls):
107 super(BaseNetworkTest, cls).resource_setup()
108
109 cls.networks = []
Miguel Lavalle124378b2016-09-21 16:41:47 -0500110 cls.admin_networks = []
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000111 cls.subnets = []
Kevin Bentonba3651c2017-09-01 17:13:01 -0700112 cls.admin_subnets = []
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000113 cls.ports = []
114 cls.routers = []
115 cls.floating_ips = []
116 cls.metering_labels = []
117 cls.service_profiles = []
118 cls.flavors = []
119 cls.metering_label_rules = []
120 cls.qos_rules = []
121 cls.qos_policies = []
122 cls.ethertype = "IPv" + str(cls._ip_version)
123 cls.address_scopes = []
124 cls.admin_address_scopes = []
125 cls.subnetpools = []
126 cls.admin_subnetpools = []
Itzik Brownbac51dc2016-10-31 12:25:04 +0000127 cls.security_groups = []
Dongcan Ye2de722e2018-07-04 11:01:37 +0000128 cls.admin_security_groups = []
Chandan Kumarc125fd12017-11-15 19:41:01 +0530129 cls.projects = []
Nguyen Phuong An67993fc2017-11-24 11:30:25 +0700130 cls.log_objects = []
Federico Ressi0ddc93b2018-04-09 12:01:48 +0200131 cls.reserved_subnet_cidrs = set()
Federico Ressiab286e42018-06-19 09:52:10 +0200132 cls.keypairs = []
Federico Ressi82e83e32018-07-03 14:19:55 +0200133 cls.trunks = []
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000134
135 @classmethod
136 def resource_cleanup(cls):
137 if CONF.service_available.neutron:
Federico Ressi82e83e32018-07-03 14:19:55 +0200138 # Clean up trunks
139 for trunk in cls.trunks:
140 cls._try_delete_resource(cls.delete_trunk, trunk)
141
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000142 # Clean up floating IPs
143 for floating_ip in cls.floating_ips:
Federico Ressia69dcd52018-07-06 09:45:34 +0200144 cls._try_delete_resource(cls.delete_floatingip, floating_ip)
145
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000146 # Clean up routers
147 for router in cls.routers:
148 cls._try_delete_resource(cls.delete_router,
149 router)
150 # Clean up metering label rules
151 for metering_label_rule in cls.metering_label_rules:
152 cls._try_delete_resource(
153 cls.admin_client.delete_metering_label_rule,
154 metering_label_rule['id'])
155 # Clean up metering labels
156 for metering_label in cls.metering_labels:
157 cls._try_delete_resource(
158 cls.admin_client.delete_metering_label,
159 metering_label['id'])
160 # Clean up flavors
161 for flavor in cls.flavors:
162 cls._try_delete_resource(
163 cls.admin_client.delete_flavor,
164 flavor['id'])
165 # Clean up service profiles
166 for service_profile in cls.service_profiles:
167 cls._try_delete_resource(
168 cls.admin_client.delete_service_profile,
169 service_profile['id'])
170 # Clean up ports
171 for port in cls.ports:
172 cls._try_delete_resource(cls.client.delete_port,
173 port['id'])
174 # Clean up subnets
175 for subnet in cls.subnets:
176 cls._try_delete_resource(cls.client.delete_subnet,
177 subnet['id'])
Kevin Bentonba3651c2017-09-01 17:13:01 -0700178 # Clean up admin subnets
179 for subnet in cls.admin_subnets:
180 cls._try_delete_resource(cls.admin_client.delete_subnet,
181 subnet['id'])
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000182 # Clean up networks
183 for network in cls.networks:
Federico Ressi61b564e2018-07-06 08:10:31 +0200184 cls._try_delete_resource(cls.delete_network, network)
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000185
Miguel Lavalle124378b2016-09-21 16:41:47 -0500186 # Clean up admin networks
187 for network in cls.admin_networks:
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000188 cls._try_delete_resource(cls.admin_client.delete_network,
189 network['id'])
190
Itzik Brownbac51dc2016-10-31 12:25:04 +0000191 # Clean up security groups
192 for secgroup in cls.security_groups:
193 cls._try_delete_resource(cls.client.delete_security_group,
194 secgroup['id'])
195
Dongcan Ye2de722e2018-07-04 11:01:37 +0000196 # Clean up admin security groups
197 for secgroup in cls.admin_security_groups:
198 cls._try_delete_resource(
199 cls.admin_client.delete_security_group,
200 secgroup['id'])
201
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000202 for subnetpool in cls.subnetpools:
203 cls._try_delete_resource(cls.client.delete_subnetpool,
204 subnetpool['id'])
205
206 for subnetpool in cls.admin_subnetpools:
207 cls._try_delete_resource(cls.admin_client.delete_subnetpool,
208 subnetpool['id'])
209
210 for address_scope in cls.address_scopes:
211 cls._try_delete_resource(cls.client.delete_address_scope,
212 address_scope['id'])
213
214 for address_scope in cls.admin_address_scopes:
215 cls._try_delete_resource(
216 cls.admin_client.delete_address_scope,
217 address_scope['id'])
218
Chandan Kumarc125fd12017-11-15 19:41:01 +0530219 for project in cls.projects:
220 cls._try_delete_resource(
221 cls.identity_admin_client.delete_project,
222 project['id'])
223
Sławek Kapłońskie100c4d2017-08-23 21:18:34 +0000224 # Clean up QoS rules
225 for qos_rule in cls.qos_rules:
226 cls._try_delete_resource(cls.admin_client.delete_qos_rule,
227 qos_rule['id'])
228 # Clean up QoS policies
229 # as all networks and ports are already removed, QoS policies
230 # shouldn't be "in use"
231 for qos_policy in cls.qos_policies:
232 cls._try_delete_resource(cls.admin_client.delete_qos_policy,
233 qos_policy['id'])
234
Nguyen Phuong An67993fc2017-11-24 11:30:25 +0700235 # Clean up log_objects
236 for log_object in cls.log_objects:
237 cls._try_delete_resource(cls.admin_client.delete_log,
238 log_object['id'])
239
Federico Ressiab286e42018-06-19 09:52:10 +0200240 for keypair in cls.keypairs:
241 cls._try_delete_resource(cls.delete_keypair, keypair)
242
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000243 super(BaseNetworkTest, cls).resource_cleanup()
244
245 @classmethod
246 def _try_delete_resource(cls, delete_callable, *args, **kwargs):
247 """Cleanup resources in case of test-failure
248
249 Some resources are explicitly deleted by the test.
250 If the test failed to delete a resource, this method will execute
251 the appropriate delete methods. Otherwise, the method ignores NotFound
252 exceptions thrown for resources that were correctly deleted by the
253 test.
254
255 :param delete_callable: delete method
256 :param args: arguments for delete method
257 :param kwargs: keyword arguments for delete method
258 """
259 try:
260 delete_callable(*args, **kwargs)
261 # if resource is not found, this means it was deleted in the test
262 except lib_exc.NotFound:
263 pass
264
265 @classmethod
Federico Ressi61b564e2018-07-06 08:10:31 +0200266 def create_network(cls, network_name=None, client=None, external=None,
267 shared=None, provider_network_type=None,
268 provider_physical_network=None,
269 provider_segmentation_id=None, **kwargs):
270 """Create a network.
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000271
Federico Ressi61b564e2018-07-06 08:10:31 +0200272 When client is not provider and admin_client is attribute is not None
273 (for example when using BaseAdminNetworkTest base class) and using any
274 of the convenience parameters (external, shared, provider_network_type,
275 provider_physical_network and provider_segmentation_id) it silently
276 uses admin_client. If the network is not shared then it uses the same
277 project_id as regular client.
278
279 :param network_name: Human-readable name of the network
280
281 :param client: client to be used for connecting to network service
282
283 :param external: indicates whether the network has an external routing
284 facility that's not managed by the networking service.
285
286 :param shared: indicates whether this resource is shared across all
287 projects. By default, only administrative users can change this value.
288 If True and admin_client attribute is not None, then the network is
289 created under administrative project.
290
291 :param provider_network_type: the type of physical network that this
292 network should be mapped to. For example, 'flat', 'vlan', 'vxlan', or
293 'gre'. Valid values depend on a networking back-end.
294
295 :param provider_physical_network: the physical network where this
296 network should be implemented. The Networking API v2.0 does not provide
297 a way to list available physical networks. For example, the Open
298 vSwitch plug-in configuration file defines a symbolic name that maps to
299 specific bridges on each compute host.
300
301 :param provider_segmentation_id: The ID of the isolated segment on the
302 physical network. The network_type attribute defines the segmentation
303 model. For example, if the network_type value is 'vlan', this ID is a
304 vlan identifier. If the network_type value is 'gre', this ID is a gre
305 key.
306
307 :param **kwargs: extra parameters to be forwarded to network service
308 """
309
310 name = (network_name or kwargs.pop('name', None) or
311 data_utils.rand_name('test-network-'))
312
313 # translate convenience parameters
314 admin_client_required = False
315 if provider_network_type:
316 admin_client_required = True
317 kwargs['provider:network_type'] = provider_network_type
318 if provider_physical_network:
319 admin_client_required = True
320 kwargs['provider:physical_network'] = provider_physical_network
321 if provider_segmentation_id:
322 admin_client_required = True
323 kwargs['provider:segmentation_id'] = provider_segmentation_id
324 if external is not None:
325 admin_client_required = True
326 kwargs['router:external'] = bool(external)
327 if shared is not None:
328 admin_client_required = True
329 kwargs['shared'] = bool(shared)
330
331 if not client:
332 if admin_client_required and cls.admin_client:
333 # For convenience silently switch to admin client
334 client = cls.admin_client
335 if not shared:
336 # Keep this network visible from current project
337 project_id = (kwargs.get('project_id') or
338 kwargs.get('tenant_id') or
339 cls.client.tenant_id)
340 kwargs.update(project_id=project_id, tenant_id=project_id)
341 else:
342 # Use default client
343 client = cls.client
344
345 network = client.create_network(name=name, **kwargs)['network']
346 network['client'] = client
347 cls.networks.append(network)
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000348 return network
349
350 @classmethod
Federico Ressi61b564e2018-07-06 08:10:31 +0200351 def delete_network(cls, network, client=None):
352 client = client or network.get('client') or cls.client
353 client.delete_network(network['id'])
354
355 @classmethod
356 def create_shared_network(cls, network_name=None, **kwargs):
357 return cls.create_network(name=network_name, shared=True, **kwargs)
Miguel Lavalle124378b2016-09-21 16:41:47 -0500358
359 @classmethod
360 def create_network_keystone_v3(cls, network_name=None, project_id=None,
361 tenant_id=None, client=None):
Federico Ressi61b564e2018-07-06 08:10:31 +0200362 params = {}
363 if project_id:
364 params['project_id'] = project_id
365 if tenant_id:
366 params['tenant_id'] = tenant_id
367 return cls.create_network(name=network_name, client=client, **params)
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000368
369 @classmethod
Sławek Kapłońskid98e27d2018-05-07 16:16:28 +0200370 def create_subnet(cls, network, gateway='', cidr=None, mask_bits=None,
Federico Ressi98f20ec2018-05-11 06:09:49 +0200371 ip_version=None, client=None, reserve_cidr=True,
372 **kwargs):
Federico Ressi0ddc93b2018-04-09 12:01:48 +0200373 """Wrapper utility that returns a test subnet.
374
375 Convenient wrapper for client.create_subnet method. It reserves and
376 allocates CIDRs to avoid creating overlapping subnets.
377
378 :param network: network where to create the subnet
379 network['id'] must contain the ID of the network
380
381 :param gateway: gateway IP address
382 It can be a str or a netaddr.IPAddress
383 If gateway is not given, then it will use default address for
384 given subnet CIDR, like "192.168.0.1" for "192.168.0.0/24" CIDR
Sławek Kapłońskid98e27d2018-05-07 16:16:28 +0200385 if gateway is given as None then no gateway will be assigned
Federico Ressi0ddc93b2018-04-09 12:01:48 +0200386
387 :param cidr: CIDR of the subnet to create
388 It can be either None, a str or a netaddr.IPNetwork instance
389
390 :param mask_bits: CIDR prefix length
391 It can be either None or a numeric value.
392 If cidr parameter is given then mask_bits is used to determinate a
393 sequence of valid CIDR to use as generated.
394 Please see netaddr.IPNetwork.subnet method documentation[1]
395
396 :param ip_version: ip version of generated subnet CIDRs
397 It can be None, IP_VERSION_4 or IP_VERSION_6
398 It has to match given either given CIDR and gateway
399
400 :param ip_version: numeric value (either IP_VERSION_4 or IP_VERSION_6)
401 this value must match CIDR and gateway IP versions if any of them is
402 given
403
404 :param client: client to be used to connect to network service
405
Federico Ressi98f20ec2018-05-11 06:09:49 +0200406 :param reserve_cidr: if True then it reserves assigned CIDR to avoid
407 using the same CIDR for further subnets in the scope of the same
408 test case class
409
Federico Ressi0ddc93b2018-04-09 12:01:48 +0200410 :param **kwargs: optional parameters to be forwarded to wrapped method
411
412 [1] http://netaddr.readthedocs.io/en/latest/tutorial_01.html#supernets-and-subnets # noqa
413 """
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000414
415 # allow tests to use admin client
416 if not client:
417 client = cls.client
418
Federico Ressi0ddc93b2018-04-09 12:01:48 +0200419 if gateway:
420 gateway_ip = netaddr.IPAddress(gateway)
421 if ip_version:
422 if ip_version != gateway_ip.version:
423 raise ValueError(
424 "Gateway IP version doesn't match IP version")
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000425 else:
Federico Ressi0ddc93b2018-04-09 12:01:48 +0200426 ip_version = gateway_ip.version
Sławek Kapłońskid98e27d2018-05-07 16:16:28 +0200427 else:
428 ip_version = ip_version or cls._ip_version
Federico Ressi0ddc93b2018-04-09 12:01:48 +0200429
430 for subnet_cidr in cls.get_subnet_cidrs(
431 ip_version=ip_version, cidr=cidr, mask_bits=mask_bits):
Federico Ressi98f20ec2018-05-11 06:09:49 +0200432 if gateway is not None:
433 kwargs['gateway_ip'] = str(gateway or (subnet_cidr.ip + 1))
Slawek Kaplonski21f53422018-11-02 16:02:09 +0100434 else:
435 kwargs['gateway_ip'] = None
Federico Ressi98f20ec2018-05-11 06:09:49 +0200436 try:
437 body = client.create_subnet(
438 network_id=network['id'],
439 cidr=str(subnet_cidr),
440 ip_version=subnet_cidr.version,
441 **kwargs)
442 break
443 except lib_exc.BadRequest as e:
444 if 'overlaps with another subnet' not in str(e):
445 raise
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000446 else:
447 message = 'Available CIDR for subnet creation could not be found'
448 raise ValueError(message)
449 subnet = body['subnet']
Kevin Bentonba3651c2017-09-01 17:13:01 -0700450 if client is cls.client:
451 cls.subnets.append(subnet)
452 else:
453 cls.admin_subnets.append(subnet)
Federico Ressi98f20ec2018-05-11 06:09:49 +0200454 if reserve_cidr:
455 cls.reserve_subnet_cidr(subnet_cidr)
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000456 return subnet
457
458 @classmethod
Federico Ressi0ddc93b2018-04-09 12:01:48 +0200459 def reserve_subnet_cidr(cls, addr, **ipnetwork_kwargs):
460 """Reserve given subnet CIDR making sure it is not used by create_subnet
461
462 :param addr: the CIDR address to be reserved
463 It can be a str or netaddr.IPNetwork instance
464
465 :param **ipnetwork_kwargs: optional netaddr.IPNetwork constructor
466 parameters
467 """
468
469 if not cls.try_reserve_subnet_cidr(addr, **ipnetwork_kwargs):
470 raise ValueError('Subnet CIDR already reserved: %r'.format(
471 addr))
472
473 @classmethod
474 def try_reserve_subnet_cidr(cls, addr, **ipnetwork_kwargs):
475 """Reserve given subnet CIDR if it hasn't been reserved before
476
477 :param addr: the CIDR address to be reserved
478 It can be a str or netaddr.IPNetwork instance
479
480 :param **ipnetwork_kwargs: optional netaddr.IPNetwork constructor
481 parameters
482
483 :return: True if it wasn't reserved before, False elsewhere.
484 """
485
486 subnet_cidr = netaddr.IPNetwork(addr, **ipnetwork_kwargs)
487 if subnet_cidr in cls.reserved_subnet_cidrs:
488 return False
489 else:
490 cls.reserved_subnet_cidrs.add(subnet_cidr)
491 return True
492
493 @classmethod
494 def get_subnet_cidrs(
495 cls, cidr=None, mask_bits=None, ip_version=None):
496 """Iterate over a sequence of unused subnet CIDR for IP version
497
498 :param cidr: CIDR of the subnet to create
499 It can be either None, a str or a netaddr.IPNetwork instance
500
501 :param mask_bits: CIDR prefix length
502 It can be either None or a numeric value.
503 If cidr parameter is given then mask_bits is used to determinate a
504 sequence of valid CIDR to use as generated.
505 Please see netaddr.IPNetwork.subnet method documentation[1]
506
507 :param ip_version: ip version of generated subnet CIDRs
508 It can be None, IP_VERSION_4 or IP_VERSION_6
509 It has to match given CIDR if given
510
511 :return: iterator over reserved CIDRs of type netaddr.IPNetwork
512
513 [1] http://netaddr.readthedocs.io/en/latest/tutorial_01.html#supernets-and-subnets # noqa
514 """
515
516 if cidr:
517 # Generate subnet CIDRs starting from given CIDR
518 # checking it is of requested IP version
519 cidr = netaddr.IPNetwork(cidr, version=ip_version)
520 else:
521 # Generate subnet CIDRs starting from configured values
522 ip_version = ip_version or cls._ip_version
523 if ip_version == const.IP_VERSION_4:
524 mask_bits = mask_bits or config.safe_get_config_value(
525 'network', 'project_network_mask_bits')
526 cidr = netaddr.IPNetwork(config.safe_get_config_value(
527 'network', 'project_network_cidr'))
528 elif ip_version == const.IP_VERSION_6:
529 mask_bits = config.safe_get_config_value(
530 'network', 'project_network_v6_mask_bits')
531 cidr = netaddr.IPNetwork(config.safe_get_config_value(
532 'network', 'project_network_v6_cidr'))
533 else:
534 raise ValueError('Invalid IP version: {!r}'.format(ip_version))
535
536 if mask_bits:
537 subnet_cidrs = cidr.subnet(mask_bits)
538 else:
539 subnet_cidrs = iter([cidr])
540
541 for subnet_cidr in subnet_cidrs:
542 if subnet_cidr not in cls.reserved_subnet_cidrs:
543 yield subnet_cidr
544
545 @classmethod
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000546 def create_port(cls, network, **kwargs):
547 """Wrapper utility that returns a test port."""
Edan Davidd75e48e2018-01-03 02:49:52 -0500548 if CONF.network.port_vnic_type and 'binding:vnic_type' not in kwargs:
549 kwargs['binding:vnic_type'] = CONF.network.port_vnic_type
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000550 body = cls.client.create_port(network_id=network['id'],
551 **kwargs)
552 port = body['port']
553 cls.ports.append(port)
554 return port
555
556 @classmethod
557 def update_port(cls, port, **kwargs):
558 """Wrapper utility that updates a test port."""
559 body = cls.client.update_port(port['id'],
560 **kwargs)
561 return body['port']
562
563 @classmethod
Genadi Chereshnyac0411e92016-07-11 16:59:42 +0300564 def _create_router_with_client(
565 cls, client, router_name=None, admin_state_up=False,
566 external_network_id=None, enable_snat=None, **kwargs
567 ):
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000568 ext_gw_info = {}
569 if external_network_id:
570 ext_gw_info['network_id'] = external_network_id
YAMAMOTO Takashi9bd4f972017-06-20 12:49:30 +0900571 if enable_snat is not None:
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000572 ext_gw_info['enable_snat'] = enable_snat
Genadi Chereshnyac0411e92016-07-11 16:59:42 +0300573 body = client.create_router(
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000574 router_name, external_gateway_info=ext_gw_info,
575 admin_state_up=admin_state_up, **kwargs)
576 router = body['router']
577 cls.routers.append(router)
578 return router
579
580 @classmethod
Genadi Chereshnyac0411e92016-07-11 16:59:42 +0300581 def create_router(cls, *args, **kwargs):
582 return cls._create_router_with_client(cls.client, *args, **kwargs)
583
584 @classmethod
585 def create_admin_router(cls, *args, **kwargs):
rajat294495c042017-06-28 15:37:16 +0530586 return cls._create_router_with_client(cls.os_admin.network_client,
Genadi Chereshnyac0411e92016-07-11 16:59:42 +0300587 *args, **kwargs)
588
589 @classmethod
Federico Ressia69dcd52018-07-06 09:45:34 +0200590 def create_floatingip(cls, external_network_id=None, port=None,
591 client=None, **kwargs):
592 """Creates a floating IP.
593
594 Create a floating IP and schedule it for later deletion.
595 If a client is passed, then it is used for deleting the IP too.
596
597 :param external_network_id: network ID where to create
598 By default this is 'CONF.network.public_network_id'.
599
600 :param port: port to bind floating IP to
601 This is translated to 'port_id=port['id']'
602 By default it is None.
603
604 :param client: network client to be used for creating and cleaning up
605 the floating IP.
606
607 :param **kwargs: additional creation parameters to be forwarded to
608 networking server.
609 """
610
611 client = client or cls.client
612 external_network_id = (external_network_id or
613 cls.external_network_id)
614
615 if port:
Federico Ressi47f6ae42018-09-24 16:19:14 +0200616 port_id = kwargs.setdefault('port_id', port['id'])
617 if port_id != port['id']:
618 message = "Port ID specified twice: {!s} != {!s}".format(
619 port_id, port['id'])
620 raise ValueError(message)
Federico Ressia69dcd52018-07-06 09:45:34 +0200621
622 fip = client.create_floatingip(external_network_id,
623 **kwargs)['floatingip']
624
625 # save client to be used later in cls.delete_floatingip
626 # for final cleanup
627 fip['client'] = client
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000628 cls.floating_ips.append(fip)
629 return fip
630
631 @classmethod
Federico Ressia69dcd52018-07-06 09:45:34 +0200632 def delete_floatingip(cls, floating_ip, client=None):
633 """Delete floating IP
634
635 :param client: Client to be used
636 If client is not given it will use the client used to create
637 the floating IP, or cls.client if unknown.
638 """
639
640 client = client or floating_ip.get('client') or cls.client
641 client.delete_floatingip(floating_ip['id'])
642
643 @classmethod
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000644 def create_router_interface(cls, router_id, subnet_id):
645 """Wrapper utility that returns a router interface."""
646 interface = cls.client.add_router_interface_with_subnet_id(
647 router_id, subnet_id)
648 return interface
649
650 @classmethod
Sławek Kapłońskiff294062016-12-04 15:00:54 +0000651 def get_supported_qos_rule_types(cls):
652 body = cls.client.list_qos_rule_types()
653 return [rule_type['type'] for rule_type in body['rule_types']]
654
655 @classmethod
Ihar Hrachyshkab7940d92016-06-10 13:44:22 +0200656 def create_qos_policy(cls, name, description=None, shared=False,
Hirofumi Ichihara39a6ee12017-08-23 13:55:12 +0900657 tenant_id=None, is_default=False):
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000658 """Wrapper utility that returns a test QoS policy."""
659 body = cls.admin_client.create_qos_policy(
Hirofumi Ichihara39a6ee12017-08-23 13:55:12 +0900660 name, description, shared, tenant_id, is_default)
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000661 qos_policy = body['policy']
662 cls.qos_policies.append(qos_policy)
663 return qos_policy
664
665 @classmethod
Sławek Kapłoński153f3452017-03-24 22:04:53 +0000666 def create_qos_bandwidth_limit_rule(cls, policy_id, max_kbps,
667 max_burst_kbps,
Chandan Kumarc125fd12017-11-15 19:41:01 +0530668 direction=const.EGRESS_DIRECTION):
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000669 """Wrapper utility that returns a test QoS bandwidth limit rule."""
670 body = cls.admin_client.create_bandwidth_limit_rule(
Sławek Kapłoński153f3452017-03-24 22:04:53 +0000671 policy_id, max_kbps, max_burst_kbps, direction)
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000672 qos_rule = body['bandwidth_limit_rule']
673 cls.qos_rules.append(qos_rule)
674 return qos_rule
675
676 @classmethod
Jakub Libosvar83704832017-12-06 16:02:28 +0000677 def delete_router(cls, router, client=None):
678 client = client or cls.client
679 body = client.list_router_interfaces(router['id'])
Chandan Kumarc125fd12017-11-15 19:41:01 +0530680 interfaces = [port for port in body['ports']
681 if port['device_owner'] in const.ROUTER_INTERFACE_OWNERS]
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000682 for i in interfaces:
683 try:
Jakub Libosvar83704832017-12-06 16:02:28 +0000684 client.remove_router_interface_with_subnet_id(
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000685 router['id'], i['fixed_ips'][0]['subnet_id'])
686 except lib_exc.NotFound:
687 pass
Jakub Libosvar83704832017-12-06 16:02:28 +0000688 client.delete_router(router['id'])
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000689
690 @classmethod
691 def create_address_scope(cls, name, is_admin=False, **kwargs):
692 if is_admin:
693 body = cls.admin_client.create_address_scope(name=name, **kwargs)
694 cls.admin_address_scopes.append(body['address_scope'])
695 else:
696 body = cls.client.create_address_scope(name=name, **kwargs)
697 cls.address_scopes.append(body['address_scope'])
698 return body['address_scope']
699
700 @classmethod
701 def create_subnetpool(cls, name, is_admin=False, **kwargs):
702 if is_admin:
703 body = cls.admin_client.create_subnetpool(name, **kwargs)
704 cls.admin_subnetpools.append(body['subnetpool'])
705 else:
706 body = cls.client.create_subnetpool(name, **kwargs)
707 cls.subnetpools.append(body['subnetpool'])
708 return body['subnetpool']
709
Chandan Kumarc125fd12017-11-15 19:41:01 +0530710 @classmethod
711 def create_project(cls, name=None, description=None):
712 test_project = name or data_utils.rand_name('test_project_')
713 test_description = description or data_utils.rand_name('desc_')
714 project = cls.identity_admin_client.create_project(
715 name=test_project,
716 description=test_description)['project']
717 cls.projects.append(project)
Dongcan Ye2de722e2018-07-04 11:01:37 +0000718 # Create a project will create a default security group.
719 # We make these security groups into admin_security_groups.
720 sgs_list = cls.admin_client.list_security_groups(
721 tenant_id=project['id'])['security_groups']
722 for sg in sgs_list:
723 cls.admin_security_groups.append(sg)
Chandan Kumarc125fd12017-11-15 19:41:01 +0530724 return project
725
726 @classmethod
727 def create_security_group(cls, name, **kwargs):
728 body = cls.client.create_security_group(name=name, **kwargs)
729 cls.security_groups.append(body['security_group'])
730 return body['security_group']
731
Federico Ressiab286e42018-06-19 09:52:10 +0200732 @classmethod
733 def create_keypair(cls, client=None, name=None, **kwargs):
734 client = client or cls.os_primary.keypairs_client
735 name = name or data_utils.rand_name('keypair-test')
736 keypair = client.create_keypair(name=name, **kwargs)['keypair']
737
738 # save client for later cleanup
739 keypair['client'] = client
740 cls.keypairs.append(keypair)
741 return keypair
742
743 @classmethod
744 def delete_keypair(cls, keypair, client=None):
745 client = (client or keypair.get('client') or
746 cls.os_primary.keypairs_client)
747 client.delete_keypair(keypair_name=keypair['name'])
748
Federico Ressi82e83e32018-07-03 14:19:55 +0200749 @classmethod
750 def create_trunk(cls, port=None, subports=None, client=None, **kwargs):
751 """Create network trunk
752
753 :param port: dictionary containing parent port ID (port['id'])
754 :param client: client to be used for connecting to networking service
755 :param **kwargs: extra parameters to be forwarded to network service
756
757 :returns: dictionary containing created trunk details
758 """
759 client = client or cls.client
760
761 if port:
762 kwargs['port_id'] = port['id']
763
764 trunk = client.create_trunk(subports=subports, **kwargs)['trunk']
765 # Save client reference for later deletion
766 trunk['client'] = client
767 cls.trunks.append(trunk)
768 return trunk
769
770 @classmethod
771 def delete_trunk(cls, trunk, client=None):
772 """Delete network trunk
773
774 :param trunk: dictionary containing trunk ID (trunk['id'])
775
776 :param client: client to be used for connecting to networking service
777 """
778 client = client or trunk.get('client') or cls.client
779 trunk.update(client.show_trunk(trunk['id'])['trunk'])
780
781 if not trunk['admin_state_up']:
782 # Cannot touch trunk before admin_state_up is True
783 client.update_trunk(trunk['id'], admin_state_up=True)
784 if trunk['sub_ports']:
785 # Removes trunk ports before deleting it
786 cls._try_delete_resource(client.remove_subports, trunk['id'],
787 trunk['sub_ports'])
788
789 # we have to detach the interface from the server before
790 # the trunk can be deleted.
791 parent_port = {'id': trunk['port_id']}
792
793 def is_parent_port_detached():
794 parent_port.update(client.show_port(parent_port['id'])['port'])
795 return not parent_port['device_id']
796
797 if not is_parent_port_detached():
798 # this could probably happen when trunk is deleted and parent port
799 # has been assigned to a VM that is still running. Here we are
800 # assuming that device_id points to such VM.
801 cls.os_primary.compute.InterfacesClient().delete_interface(
802 parent_port['device_id'], parent_port['id'])
803 utils.wait_until_true(is_parent_port_detached)
804
805 client.delete_trunk(trunk['id'])
806
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000807
808class BaseAdminNetworkTest(BaseNetworkTest):
809
810 credentials = ['primary', 'admin']
811
812 @classmethod
813 def setup_clients(cls):
814 super(BaseAdminNetworkTest, cls).setup_clients()
fumihiko kakumaa216fc12017-07-14 10:43:29 +0900815 cls.admin_client = cls.os_admin.network_client
Jakub Libosvarf5758012017-08-15 13:45:30 +0000816 cls.identity_admin_client = cls.os_admin.projects_client
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000817
818 @classmethod
819 def create_metering_label(cls, name, description):
820 """Wrapper utility that returns a test metering label."""
821 body = cls.admin_client.create_metering_label(
822 description=description,
823 name=data_utils.rand_name("metering-label"))
824 metering_label = body['metering_label']
825 cls.metering_labels.append(metering_label)
826 return metering_label
827
828 @classmethod
829 def create_metering_label_rule(cls, remote_ip_prefix, direction,
830 metering_label_id):
831 """Wrapper utility that returns a test metering label rule."""
832 body = cls.admin_client.create_metering_label_rule(
833 remote_ip_prefix=remote_ip_prefix, direction=direction,
834 metering_label_id=metering_label_id)
835 metering_label_rule = body['metering_label_rule']
836 cls.metering_label_rules.append(metering_label_rule)
837 return metering_label_rule
838
839 @classmethod
840 def create_flavor(cls, name, description, service_type):
841 """Wrapper utility that returns a test flavor."""
842 body = cls.admin_client.create_flavor(
843 description=description, service_type=service_type,
844 name=name)
845 flavor = body['flavor']
846 cls.flavors.append(flavor)
847 return flavor
848
849 @classmethod
850 def create_service_profile(cls, description, metainfo, driver):
851 """Wrapper utility that returns a test service profile."""
852 body = cls.admin_client.create_service_profile(
853 driver=driver, metainfo=metainfo, description=description)
854 service_profile = body['service_profile']
855 cls.service_profiles.append(service_profile)
856 return service_profile
857
858 @classmethod
Nguyen Phuong An67993fc2017-11-24 11:30:25 +0700859 def create_log(cls, name, description=None,
860 resource_type='security_group', resource_id=None,
861 target_id=None, event='ALL', enabled=True):
862 """Wrapper utility that returns a test log object."""
863 log_args = {'name': name,
864 'description': description,
865 'resource_type': resource_type,
866 'resource_id': resource_id,
867 'target_id': target_id,
868 'event': event,
869 'enabled': enabled}
870 body = cls.admin_client.create_log(**log_args)
871 log_object = body['log']
872 cls.log_objects.append(log_object)
873 return log_object
874
875 @classmethod
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000876 def get_unused_ip(cls, net_id, ip_version=None):
Gary Kotton011345f2016-06-15 08:04:31 -0700877 """Get an unused ip address in a allocation pool of net"""
Daniel Mellado3c0aeab2016-01-29 11:30:25 +0000878 body = cls.admin_client.list_ports(network_id=net_id)
879 ports = body['ports']
880 used_ips = []
881 for port in ports:
882 used_ips.extend(
883 [fixed_ip['ip_address'] for fixed_ip in port['fixed_ips']])
884 body = cls.admin_client.list_subnets(network_id=net_id)
885 subnets = body['subnets']
886
887 for subnet in subnets:
888 if ip_version and subnet['ip_version'] != ip_version:
889 continue
890 cidr = subnet['cidr']
891 allocation_pools = subnet['allocation_pools']
892 iterators = []
893 if allocation_pools:
894 for allocation_pool in allocation_pools:
895 iterators.append(netaddr.iter_iprange(
896 allocation_pool['start'], allocation_pool['end']))
897 else:
898 net = netaddr.IPNetwork(cidr)
899
900 def _iterip():
901 for ip in net:
902 if ip not in (net.network, net.broadcast):
903 yield ip
904 iterators.append(iter(_iterip()))
905
906 for iterator in iterators:
907 for ip in iterator:
908 if str(ip) not in used_ips:
909 return str(ip)
910
911 message = (
912 "net(%s) has no usable IP address in allocation pools" % net_id)
913 raise exceptions.InvalidConfiguration(message)
Ihar Hrachyshka59382252016-04-05 15:54:33 +0200914
915
Sławek Kapłońskiff294062016-12-04 15:00:54 +0000916def require_qos_rule_type(rule_type):
917 def decorator(f):
918 @functools.wraps(f)
919 def wrapper(self, *func_args, **func_kwargs):
920 if rule_type not in self.get_supported_qos_rule_types():
921 raise self.skipException(
922 "%s rule type is required." % rule_type)
923 return f(self, *func_args, **func_kwargs)
924 return wrapper
925 return decorator
926
927
Ihar Hrachyshka59382252016-04-05 15:54:33 +0200928def _require_sorting(f):
929 @functools.wraps(f)
930 def inner(self, *args, **kwargs):
Chandan Kumarc125fd12017-11-15 19:41:01 +0530931 if not tutils.is_extension_enabled("sorting", "network"):
Ihar Hrachyshka59382252016-04-05 15:54:33 +0200932 self.skipTest('Sorting feature is required')
933 return f(self, *args, **kwargs)
934 return inner
935
936
937def _require_pagination(f):
938 @functools.wraps(f)
939 def inner(self, *args, **kwargs):
Chandan Kumarc125fd12017-11-15 19:41:01 +0530940 if not tutils.is_extension_enabled("pagination", "network"):
Ihar Hrachyshka59382252016-04-05 15:54:33 +0200941 self.skipTest('Pagination feature is required')
942 return f(self, *args, **kwargs)
943 return inner
944
945
946class BaseSearchCriteriaTest(BaseNetworkTest):
947
948 # This should be defined by subclasses to reflect resource name to test
949 resource = None
950
Armando Migliaccio57581c62016-07-01 10:13:19 -0700951 field = 'name'
952
Ihar Hrachyshkaa8fe5a12016-05-24 14:50:58 +0200953 # NOTE(ihrachys): some names, like those starting with an underscore (_)
954 # are sorted differently depending on whether the plugin implements native
955 # sorting support, or not. So we avoid any such cases here, sticking to
956 # alphanumeric. Also test a case when there are multiple resources with the
957 # same name
Ihar Hrachyshka59382252016-04-05 15:54:33 +0200958 resource_names = ('test1', 'abc1', 'test10', '123test') + ('test1',)
959
Ihar Hrachyshka59382252016-04-05 15:54:33 +0200960 force_tenant_isolation = True
961
Ihar Hrachyshkaa8fe5a12016-05-24 14:50:58 +0200962 list_kwargs = {}
Ihar Hrachyshka59382252016-04-05 15:54:33 +0200963
Ihar Hrachyshkab7940d92016-06-10 13:44:22 +0200964 list_as_admin = False
965
Ihar Hrachyshkaaeb03a02016-05-18 20:03:18 +0200966 def assertSameOrder(self, original, actual):
967 # gracefully handle iterators passed
968 original = list(original)
969 actual = list(actual)
970 self.assertEqual(len(original), len(actual))
971 for expected, res in zip(original, actual):
Armando Migliaccio57581c62016-07-01 10:13:19 -0700972 self.assertEqual(expected[self.field], res[self.field])
Ihar Hrachyshkaaeb03a02016-05-18 20:03:18 +0200973
974 @utils.classproperty
975 def plural_name(self):
976 return '%ss' % self.resource
977
Ihar Hrachyshkab7940d92016-06-10 13:44:22 +0200978 @property
979 def list_client(self):
980 return self.admin_client if self.list_as_admin else self.client
981
Ihar Hrachyshka59382252016-04-05 15:54:33 +0200982 def list_method(self, *args, **kwargs):
Ihar Hrachyshkab7940d92016-06-10 13:44:22 +0200983 method = getattr(self.list_client, 'list_%s' % self.plural_name)
Ihar Hrachyshka59382252016-04-05 15:54:33 +0200984 kwargs.update(self.list_kwargs)
985 return method(*args, **kwargs)
986
Ihar Hrachyshkaaeb03a02016-05-18 20:03:18 +0200987 def get_bare_url(self, url):
988 base_url = self.client.base_url
989 self.assertTrue(url.startswith(base_url))
990 return url[len(base_url):]
991
Ihar Hrachyshka59382252016-04-05 15:54:33 +0200992 @classmethod
993 def _extract_resources(cls, body):
Ihar Hrachyshkaaeb03a02016-05-18 20:03:18 +0200994 return body[cls.plural_name]
Ihar Hrachyshka59382252016-04-05 15:54:33 +0200995
996 def _test_list_sorts(self, direction):
997 sort_args = {
998 'sort_dir': direction,
Armando Migliaccio57581c62016-07-01 10:13:19 -0700999 'sort_key': self.field
Ihar Hrachyshka59382252016-04-05 15:54:33 +02001000 }
1001 body = self.list_method(**sort_args)
1002 resources = self._extract_resources(body)
1003 self.assertNotEmpty(
1004 resources, "%s list returned is empty" % self.resource)
Armando Migliaccio57581c62016-07-01 10:13:19 -07001005 retrieved_names = [res[self.field] for res in resources]
Ihar Hrachyshka59382252016-04-05 15:54:33 +02001006 expected = sorted(retrieved_names)
1007 if direction == constants.SORT_DIRECTION_DESC:
1008 expected = list(reversed(expected))
1009 self.assertEqual(expected, retrieved_names)
1010
1011 @_require_sorting
1012 def _test_list_sorts_asc(self):
1013 self._test_list_sorts(constants.SORT_DIRECTION_ASC)
1014
1015 @_require_sorting
1016 def _test_list_sorts_desc(self):
1017 self._test_list_sorts(constants.SORT_DIRECTION_DESC)
1018
1019 @_require_pagination
1020 def _test_list_pagination(self):
1021 for limit in range(1, len(self.resource_names) + 1):
1022 pagination_args = {
1023 'limit': limit,
1024 }
1025 body = self.list_method(**pagination_args)
1026 resources = self._extract_resources(body)
1027 self.assertEqual(limit, len(resources))
1028
1029 @_require_pagination
1030 def _test_list_no_pagination_limit_0(self):
1031 pagination_args = {
1032 'limit': 0,
1033 }
1034 body = self.list_method(**pagination_args)
1035 resources = self._extract_resources(body)
Béla Vancsicsf1806182016-08-23 07:36:18 +02001036 self.assertGreaterEqual(len(resources), len(self.resource_names))
Ihar Hrachyshka59382252016-04-05 15:54:33 +02001037
Ihar Hrachyshkaaeb03a02016-05-18 20:03:18 +02001038 def _test_list_pagination_iteratively(self, lister):
Ihar Hrachyshka59382252016-04-05 15:54:33 +02001039 # first, collect all resources for later comparison
1040 sort_args = {
1041 'sort_dir': constants.SORT_DIRECTION_ASC,
Armando Migliaccio57581c62016-07-01 10:13:19 -07001042 'sort_key': self.field
Ihar Hrachyshka59382252016-04-05 15:54:33 +02001043 }
1044 body = self.list_method(**sort_args)
1045 expected_resources = self._extract_resources(body)
1046 self.assertNotEmpty(expected_resources)
1047
Ihar Hrachyshkaaeb03a02016-05-18 20:03:18 +02001048 resources = lister(
1049 len(expected_resources), sort_args
1050 )
1051
1052 # finally, compare that the list retrieved in one go is identical to
1053 # the one containing pagination results
1054 self.assertSameOrder(expected_resources, resources)
1055
1056 def _list_all_with_marker(self, niterations, sort_args):
Ihar Hrachyshka59382252016-04-05 15:54:33 +02001057 # paginate resources one by one, using last fetched resource as a
1058 # marker
1059 resources = []
Ihar Hrachyshkaaeb03a02016-05-18 20:03:18 +02001060 for i in range(niterations):
Ihar Hrachyshka59382252016-04-05 15:54:33 +02001061 pagination_args = sort_args.copy()
1062 pagination_args['limit'] = 1
1063 if resources:
1064 pagination_args['marker'] = resources[-1]['id']
1065 body = self.list_method(**pagination_args)
1066 resources_ = self._extract_resources(body)
1067 self.assertEqual(1, len(resources_))
1068 resources.extend(resources_)
Ihar Hrachyshkaaeb03a02016-05-18 20:03:18 +02001069 return resources
Ihar Hrachyshka59382252016-04-05 15:54:33 +02001070
Ihar Hrachyshkaaeb03a02016-05-18 20:03:18 +02001071 @_require_pagination
1072 @_require_sorting
1073 def _test_list_pagination_with_marker(self):
1074 self._test_list_pagination_iteratively(self._list_all_with_marker)
1075
1076 def _list_all_with_hrefs(self, niterations, sort_args):
1077 # paginate resources one by one, using next href links
1078 resources = []
1079 prev_links = {}
1080
1081 for i in range(niterations):
1082 if prev_links:
1083 uri = self.get_bare_url(prev_links['next'])
1084 else:
Ihar Hrachyshka7f79fe62016-06-07 21:23:44 +02001085 sort_args.update(self.list_kwargs)
Ihar Hrachyshkab7940d92016-06-10 13:44:22 +02001086 uri = self.list_client.build_uri(
Ihar Hrachyshkaaeb03a02016-05-18 20:03:18 +02001087 self.plural_name, limit=1, **sort_args)
Ihar Hrachyshkab7940d92016-06-10 13:44:22 +02001088 prev_links, body = self.list_client.get_uri_with_links(
Ihar Hrachyshkaaeb03a02016-05-18 20:03:18 +02001089 self.plural_name, uri
1090 )
1091 resources_ = self._extract_resources(body)
1092 self.assertEqual(1, len(resources_))
1093 resources.extend(resources_)
1094
1095 # The last element is empty and does not contain 'next' link
1096 uri = self.get_bare_url(prev_links['next'])
1097 prev_links, body = self.client.get_uri_with_links(
1098 self.plural_name, uri
1099 )
1100 self.assertNotIn('next', prev_links)
1101
1102 # Now walk backwards and compare results
1103 resources2 = []
1104 for i in range(niterations):
1105 uri = self.get_bare_url(prev_links['previous'])
Ihar Hrachyshkab7940d92016-06-10 13:44:22 +02001106 prev_links, body = self.list_client.get_uri_with_links(
Ihar Hrachyshkaaeb03a02016-05-18 20:03:18 +02001107 self.plural_name, uri
1108 )
1109 resources_ = self._extract_resources(body)
1110 self.assertEqual(1, len(resources_))
1111 resources2.extend(resources_)
1112
1113 self.assertSameOrder(resources, reversed(resources2))
1114
1115 return resources
1116
1117 @_require_pagination
1118 @_require_sorting
1119 def _test_list_pagination_with_href_links(self):
1120 self._test_list_pagination_iteratively(self._list_all_with_hrefs)
1121
1122 @_require_pagination
1123 @_require_sorting
1124 def _test_list_pagination_page_reverse_with_href_links(
1125 self, direction=constants.SORT_DIRECTION_ASC):
1126 pagination_args = {
1127 'sort_dir': direction,
Armando Migliaccio57581c62016-07-01 10:13:19 -07001128 'sort_key': self.field,
Ihar Hrachyshkaaeb03a02016-05-18 20:03:18 +02001129 }
1130 body = self.list_method(**pagination_args)
1131 expected_resources = self._extract_resources(body)
1132
1133 page_size = 2
1134 pagination_args['limit'] = page_size
1135
1136 prev_links = {}
1137 resources = []
1138 num_resources = len(expected_resources)
1139 niterations = int(math.ceil(float(num_resources) / page_size))
1140 for i in range(niterations):
1141 if prev_links:
1142 uri = self.get_bare_url(prev_links['previous'])
1143 else:
Ihar Hrachyshka7f79fe62016-06-07 21:23:44 +02001144 pagination_args.update(self.list_kwargs)
Ihar Hrachyshkab7940d92016-06-10 13:44:22 +02001145 uri = self.list_client.build_uri(
Ihar Hrachyshkaaeb03a02016-05-18 20:03:18 +02001146 self.plural_name, page_reverse=True, **pagination_args)
Ihar Hrachyshkab7940d92016-06-10 13:44:22 +02001147 prev_links, body = self.list_client.get_uri_with_links(
Ihar Hrachyshkaaeb03a02016-05-18 20:03:18 +02001148 self.plural_name, uri
1149 )
1150 resources_ = self._extract_resources(body)
Béla Vancsicsf1806182016-08-23 07:36:18 +02001151 self.assertGreaterEqual(page_size, len(resources_))
Ihar Hrachyshkaaeb03a02016-05-18 20:03:18 +02001152 resources.extend(reversed(resources_))
1153
1154 self.assertSameOrder(expected_resources, reversed(resources))
1155
1156 @_require_pagination
1157 @_require_sorting
1158 def _test_list_pagination_page_reverse_asc(self):
1159 self._test_list_pagination_page_reverse(
1160 direction=constants.SORT_DIRECTION_ASC)
1161
1162 @_require_pagination
1163 @_require_sorting
1164 def _test_list_pagination_page_reverse_desc(self):
1165 self._test_list_pagination_page_reverse(
1166 direction=constants.SORT_DIRECTION_DESC)
1167
1168 def _test_list_pagination_page_reverse(self, direction):
1169 pagination_args = {
1170 'sort_dir': direction,
Armando Migliaccio57581c62016-07-01 10:13:19 -07001171 'sort_key': self.field,
Ihar Hrachyshkaaeb03a02016-05-18 20:03:18 +02001172 'limit': 3,
1173 }
1174 body = self.list_method(**pagination_args)
1175 expected_resources = self._extract_resources(body)
1176
1177 pagination_args['limit'] -= 1
1178 pagination_args['marker'] = expected_resources[-1]['id']
1179 pagination_args['page_reverse'] = True
1180 body = self.list_method(**pagination_args)
1181
1182 self.assertSameOrder(
1183 # the last entry is not included in 2nd result when used as a
1184 # marker
1185 expected_resources[:-1],
1186 self._extract_resources(body))
Victor Morales1be97b42016-09-05 08:50:06 -05001187
Hongbin Lu54f55922018-07-12 19:05:39 +00001188 @tutils.requires_ext(extension="filter-validation", service="network")
1189 def _test_list_validation_filters(
1190 self, validation_args, filter_is_valid=True):
1191 if not filter_is_valid:
1192 self.assertRaises(lib_exc.BadRequest, self.list_method,
1193 **validation_args)
1194 else:
1195 body = self.list_method(**validation_args)
1196 resources = self._extract_resources(body)
1197 for resource in resources:
1198 self.assertIn(resource['name'], self.resource_names)