2 # -*- coding: utf-8 -*-
6 # This file is part of openmano
9 # Licensed under the Apache License, Version 2.0 (the "License"); you may
10 # not use this file except in compliance with the License. You may obtain
11 # a copy of the License at
13 # http://www.apache.org/licenses/LICENSE-2.0
15 # Unless required by applicable law or agreed to in writing, software
16 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
17 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
18 # License for the specific language governing permissions and limitations
25 if getenv('OSMRO_PDB_DEBUG'):
33 Module for testing openmano functionality. It uses openmanoclient.py for invoking openmano
49 from argparse
import ArgumentParser
51 __author__
= "Pablo Montes, Alfonso Tierno"
52 __date__
= "$16-Feb-2017 17:08:16$"
54 version_date
= "Oct 2017"
56 test_config
= {} # used for global variables with the test configuration
59 class test_base(unittest
.TestCase
):
65 logger
.info("{}. {}".format(test_config
["test_number"], cls
.__name
__))
68 def tearDownClass(cls
):
69 test_config
["test_number"] += 1
72 exec_info
= sys
.exc_info()
73 if exec_info
== (None, None, None):
74 logger
.info(self
.__class
__.test_text
+" -> TEST OK")
76 logger
.warning(self
.__class
__.test_text
+" -> TEST NOK")
77 logger
.critical("Traceback error",exc_info
=True)
80 def check_instance_scenario_active(uuid
):
81 instance
= test_config
["client"].get_instance(uuid
=uuid
)
83 for net
in instance
['nets']:
84 status
= net
['status']
85 if status
!= 'ACTIVE':
86 return (False, status
)
88 for vnf
in instance
['vnfs']:
91 if status
!= 'ACTIVE':
92 return (False, status
)
99 All unittest classes for code based tests must have prefix 'test_' in order to be taken into account for tests
101 class test_VIM_datacenter_tenant_operations(test_base
):
104 def test_000_create_RO_tenant(self
):
105 self
.__class
__.tenant_name
= _get_random_string(20)
106 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"], self
.__class
__.test_index
,
107 inspect
.currentframe().f_code
.co_name
)
108 self
.__class
__.test_index
+= 1
109 tenant
= test_config
["client"].create_tenant(name
=self
.__class
__.tenant_name
,
110 description
=self
.__class
__.tenant_name
)
111 logger
.debug("{}".format(tenant
))
112 self
.assertEqual(tenant
.get('tenant', {}).get('name', ''), self
.__class
__.tenant_name
)
114 def test_010_list_RO_tenant(self
):
115 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"], self
.__class
__.test_index
,
116 inspect
.currentframe().f_code
.co_name
)
117 self
.__class
__.test_index
+= 1
118 tenant
= test_config
["client"].get_tenant(name
=self
.__class
__.tenant_name
)
119 logger
.debug("{}".format(tenant
))
120 self
.assertEqual(tenant
.get('tenant', {}).get('name', ''), self
.__class
__.tenant_name
)
122 def test_020_delete_RO_tenant(self
):
123 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"], self
.__class
__.test_index
,
124 inspect
.currentframe().f_code
.co_name
)
125 self
.__class
__.test_index
+= 1
126 tenant
= test_config
["client"].delete_tenant(name
=self
.__class
__.tenant_name
)
127 logger
.debug("{}".format(tenant
))
128 assert('deleted' in tenant
.get('result',""))
131 class test_VIM_datacenter_operations(test_base
):
132 datacenter_name
= None
134 def test_000_create_datacenter(self
):
135 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"], self
.__class
__.test_index
,
136 inspect
.currentframe().f_code
.co_name
)
137 self
.__class
__.datacenter_name
= _get_random_string(20)
138 self
.__class
__.test_index
+= 1
139 self
.datacenter
= test_config
["client"].create_datacenter(name
=self
.__class
__.datacenter_name
,
140 vim_url
="http://fakeurl/fake")
141 logger
.debug("{}".format(self
.datacenter
))
142 self
.assertEqual (self
.datacenter
.get('datacenter', {}).get('name',''), self
.__class
__.datacenter_name
)
144 def test_010_list_datacenter(self
):
145 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"], self
.__class
__.test_index
,
146 inspect
.currentframe().f_code
.co_name
)
148 self
.__class
__.test_index
+= 1
149 self
.datacenter
= test_config
["client"].get_datacenter(all_tenants
=True, name
=self
.__class
__.datacenter_name
)
150 logger
.debug("{}".format(self
.datacenter
))
151 self
.assertEqual (self
.datacenter
.get('datacenter', {}).get('name', ''), self
.__class
__.datacenter_name
)
153 def test_020_attach_datacenter(self
):
154 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"], self
.__class
__.test_index
,
155 inspect
.currentframe().f_code
.co_name
)
157 self
.__class
__.test_index
+= 1
158 self
.datacenter
= test_config
["client"].attach_datacenter(name
=self
.__class
__.datacenter_name
,
159 vim_tenant_name
='fake')
160 logger
.debug("{}".format(self
.datacenter
))
161 assert ('uuid' in self
.datacenter
.get('datacenter', {}))
163 def test_030_list_attached_datacenter(self
):
164 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"], self
.__class
__.test_index
,
165 inspect
.currentframe().f_code
.co_name
)
167 self
.__class
__.test_index
+= 1
168 self
.datacenter
= test_config
["client"].get_datacenter(all_tenants
=False, name
=self
.__class
__.datacenter_name
)
169 logger
.debug("{}".format(self
.datacenter
))
170 self
.assertEqual (self
.datacenter
.get('datacenter', {}).get('name', ''), self
.__class
__.datacenter_name
)
172 def test_040_detach_datacenter(self
):
173 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"], self
.__class
__.test_index
,
174 inspect
.currentframe().f_code
.co_name
)
176 self
.__class
__.test_index
+= 1
177 self
.datacenter
= test_config
["client"].detach_datacenter(name
=self
.__class
__.datacenter_name
)
178 logger
.debug("{}".format(self
.datacenter
))
179 assert ('detached' in self
.datacenter
.get('result', ""))
181 def test_050_delete_datacenter(self
):
182 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"], self
.__class
__.test_index
,
183 inspect
.currentframe().f_code
.co_name
)
185 self
.__class
__.test_index
+= 1
186 self
.datacenter
= test_config
["client"].delete_datacenter(name
=self
.__class
__.datacenter_name
)
187 logger
.debug("{}".format(self
.datacenter
))
188 assert('deleted' in self
.datacenter
.get('result',""))
191 class test_VIM_network_operations(test_base
):
192 vim_network_name
= None
193 vim_network_uuid
= None
195 def test_000_create_VIM_network(self
):
196 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"], self
.__class
__.test_index
,
197 inspect
.currentframe().f_code
.co_name
)
198 self
.__class
__.vim_network_name
= _get_random_string(20)
199 self
.__class
__.test_index
+= 1
200 network
= test_config
["client"].vim_action("create", "networks", name
=self
.__class
__.vim_network_name
)
201 logger
.debug("{}".format(network
))
202 self
.__class
__.vim_network_uuid
= network
["network"]["id"]
203 self
.assertEqual(network
.get('network', {}).get('name', ''), self
.__class
__.vim_network_name
)
205 def test_010_list_VIM_networks(self
):
206 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"], self
.__class
__.test_index
,
207 inspect
.currentframe().f_code
.co_name
)
208 self
.__class
__.test_index
+= 1
209 networks
= test_config
["client"].vim_action("list", "networks")
210 logger
.debug("{}".format(networks
))
212 def test_020_get_VIM_network_by_uuid(self
):
213 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"], self
.__class
__.test_index
,
214 inspect
.currentframe().f_code
.co_name
)
216 self
.__class
__.test_index
+= 1
217 network
= test_config
["client"].vim_action("show", "networks", uuid
=self
.__class
__.vim_network_uuid
)
218 logger
.debug("{}".format(network
))
219 self
.assertEqual(network
.get('network', {}).get('name', ''), self
.__class
__.vim_network_name
)
221 def test_030_delete_VIM_network_by_uuid(self
):
222 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"], self
.__class
__.test_index
,
223 inspect
.currentframe().f_code
.co_name
)
225 self
.__class
__.test_index
+= 1
226 network
= test_config
["client"].vim_action("delete", "networks", uuid
=self
.__class
__.vim_network_uuid
)
227 logger
.debug("{}".format(network
))
228 assert ('deleted' in network
.get('result', ""))
231 class test_VIM_image_operations(test_base
):
233 def test_000_list_VIM_images(self
):
234 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"], self
.__class
__.test_index
,
235 inspect
.currentframe().f_code
.co_name
)
236 self
.__class
__.test_index
+= 1
237 images
= test_config
["client"].vim_action("list", "images")
238 logger
.debug("{}".format(images
))
241 The following is a non critical test that will fail most of the times.
242 In case of OpenStack datacenter these tests will only success if RO has access to the admin endpoint
243 This test will only be executed in case it is specifically requested by the user
245 class test_VIM_tenant_operations(test_base
):
246 vim_tenant_name
= None
247 vim_tenant_uuid
= None
251 test_base
.setUpClass(cls
)
252 logger
.warning("In case of OpenStack datacenter these tests will only success "
253 "if RO has access to the admin endpoint")
255 def test_000_create_VIM_tenant(self
):
256 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"], self
.__class
__.test_index
,
257 inspect
.currentframe().f_code
.co_name
)
258 self
.__class
__.vim_tenant_name
= _get_random_string(20)
259 self
.__class
__.test_index
+= 1
260 tenant
= test_config
["client"].vim_action("create", "tenants", name
=self
.__class
__.vim_tenant_name
)
261 logger
.debug("{}".format(tenant
))
262 self
.__class
__.vim_tenant_uuid
= tenant
["tenant"]["id"]
263 self
.assertEqual(tenant
.get('tenant', {}).get('name', ''), self
.__class
__.vim_tenant_name
)
265 def test_010_list_VIM_tenants(self
):
266 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"], self
.__class
__.test_index
,
267 inspect
.currentframe().f_code
.co_name
)
268 self
.__class
__.test_index
+= 1
269 tenants
= test_config
["client"].vim_action("list", "tenants")
270 logger
.debug("{}".format(tenants
))
272 def test_020_get_VIM_tenant_by_uuid(self
):
273 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"], self
.__class
__.test_index
,
274 inspect
.currentframe().f_code
.co_name
)
276 self
.__class
__.test_index
+= 1
277 tenant
= test_config
["client"].vim_action("show", "tenants", uuid
=self
.__class
__.vim_tenant_uuid
)
278 logger
.debug("{}".format(tenant
))
279 self
.assertEqual(tenant
.get('tenant', {}).get('name', ''), self
.__class
__.vim_tenant_name
)
281 def test_030_delete_VIM_tenant_by_uuid(self
):
282 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"], self
.__class
__.test_index
,
283 inspect
.currentframe().f_code
.co_name
)
285 self
.__class
__.test_index
+= 1
286 tenant
= test_config
["client"].vim_action("delete", "tenants", uuid
=self
.__class
__.vim_tenant_uuid
)
287 logger
.debug("{}".format(tenant
))
288 assert ('deleted' in tenant
.get('result', ""))
291 class test_vimconn_connect(test_base
):
293 def test_000_connect(self
):
294 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
295 self
.__class
__.test_index
,
296 inspect
.currentframe().f_code
.co_name
)
298 self
.__class
__.test_index
+= 1
299 if test_config
['vimtype'] == 'vmware':
300 vca_object
= test_config
["vim_conn"].connect()
301 logger
.debug("{}".format(vca_object
))
302 self
.assertIsNotNone(vca_object
)
303 elif test_config
['vimtype'] in ('openstack', 'azure'):
304 test_config
["vim_conn"]._reload
_connection
()
305 network_list
= test_config
["vim_conn"].get_network_list()
306 logger
.debug("{}".format(network_list
))
307 self
.assertIsNotNone(network_list
)
309 class test_vimconn_new_network(test_base
):
312 def test_000_new_network(self
):
313 self
.__class
__.network_name
= _get_random_string(20)
314 network_type
= 'bridge'
316 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
317 self
.__class
__.test_index
, inspect
.currentframe().f_code
.co_name
)
318 self
.__class
__.test_index
+= 1
320 network
, _
= test_config
["vim_conn"].new_network(net_name
=self
.__class
__.network_name
,
321 net_type
=network_type
)
322 self
.__class
__.network_id
= network
323 logger
.debug("{}".format(network
))
325 network_list
= test_config
["vim_conn"].get_network_list()
326 for net
in network_list
:
327 if self
.__class
__.network_name
in net
.get('name'):
328 self
.assertIn(self
.__class
__.network_name
, net
.get('name'))
329 self
.assertEqual(net
.get('type'), network_type
)
331 # Deleting created network
332 result
= test_config
["vim_conn"].delete_network(self
.__class
__.network_id
)
334 logger
.info("Network id {} sucessfully deleted".format(self
.__class
__.network_id
))
336 logger
.info("Failed to delete network id {}".format(self
.__class
__.network_id
))
338 def test_010_new_network_by_types(self
):
340 network_types
= ['data','bridge','mgmt']
341 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
342 self
.__class
__.test_index
,
343 inspect
.currentframe().f_code
.co_name
)
344 self
.__class
__.test_index
+= 1
345 for net_type
in network_types
:
346 self
.__class
__.network_name
= _get_random_string(20)
347 network_id
, _
= test_config
["vim_conn"].new_network(net_name
=self
.__class
__.network_name
,
350 delete_net_ids
.append(network_id
)
351 logger
.debug("{}".format(network_id
))
353 network_list
= test_config
["vim_conn"].get_network_list()
354 for net
in network_list
:
355 if self
.__class
__.network_name
in net
.get('name'):
356 self
.assertIn(self
.__class
__.network_name
, net
.get('name'))
357 if net_type
in net
.get('type'):
358 self
.assertEqual(net
.get('type'), net_type
)
360 self
.assertNotEqual(net
.get('type'), net_type
)
362 # Deleting created network
363 for net_id
in delete_net_ids
:
364 result
= test_config
["vim_conn"].delete_network(net_id
)
366 logger
.info("Network id {} sucessfully deleted".format(net_id
))
368 logger
.info("Failed to delete network id {}".format(net_id
))
370 def test_020_new_network_by_ipprofile(self
):
371 test_directory_content
= os
.listdir(test_config
["test_directory"])
373 for dir_name
in test_directory_content
:
374 if dir_name
== 'simple_multi_vnfc':
375 self
.__class
__.scenario_test_path
= test_config
["test_directory"] + '/'+ dir_name
376 vnfd_files
= glob
.glob(self
.__class
__.scenario_test_path
+'/vnfd_*.yaml')
379 for vnfd
in vnfd_files
:
380 with
open(vnfd
, 'r') as stream
:
381 vnf_descriptor
= yaml
.load(stream
)
383 internal_connections_list
= vnf_descriptor
['vnf']['internal-connections']
384 for item
in internal_connections_list
:
385 if 'ip-profile' in item
:
386 version
= item
['ip-profile']['ip-version']
387 dhcp_count
= item
['ip-profile']['dhcp']['count']
388 dhcp_enabled
= item
['ip-profile']['dhcp']['enabled']
389 dhcp_start_address
= item
['ip-profile']['dhcp']['start-address']
390 subnet_address
= item
['ip-profile']['subnet-address']
393 self
.__class
__.network_name
= _get_random_string(20)
394 ip_profile
= {'dhcp_count': dhcp_count
,
395 'dhcp_enabled': dhcp_enabled
,
396 'dhcp_start_address': dhcp_start_address
,
397 'ip_version': version
,
398 'subnet_address': subnet_address
400 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
401 self
.__class
__.test_index
,
402 inspect
.currentframe().f_code
.co_name
)
403 self
.__class
__.test_index
+= 1
404 network
, _
= test_config
["vim_conn"].new_network(net_name
=self
.__class
__.network_name
,
406 ip_profile
=ip_profile
)
407 self
.__class
__.network_id
= network
408 logger
.debug("{}".format(network
))
410 network_list
= test_config
["vim_conn"].get_network_list()
411 for net
in network_list
:
412 if self
.__class
__.network_name
in net
.get('name'):
413 self
.assertIn(self
.__class
__.network_name
, net
.get('name'))
415 # Deleting created network
416 result
= test_config
["vim_conn"].delete_network(self
.__class
__.network_id
)
418 logger
.info("Network id {} sucessfully deleted".format(self
.__class
__.network_id
))
420 logger
.info("Failed to delete network id {}".format(self
.__class
__.network_id
))
422 def test_030_new_network_by_isshared(self
):
423 self
.__class
__.network_name
= _get_random_string(20)
425 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
426 self
.__class
__.test_index
,
427 inspect
.currentframe().f_code
.co_name
)
428 self
.__class
__.test_index
+= 1
429 network
, _
= test_config
["vim_conn"].new_network(net_name
=self
.__class
__.network_name
,
432 self
.__class
__.network_id
= network
433 logger
.debug("{}".format(network
))
435 network_list
= test_config
["vim_conn"].get_network_list()
436 for net
in network_list
:
437 if self
.__class
__.network_name
in net
.get('name'):
438 self
.assertIn(self
.__class
__.network_name
, net
.get('name'))
439 self
.assertEqual(net
.get('shared'), shared
)
441 # Deleting created network
442 result
= test_config
["vim_conn"].delete_network(self
.__class
__.network_id
)
444 logger
.info("Network id {} sucessfully deleted".format(self
.__class
__.network_id
))
446 logger
.info("Failed to delete network id {}".format(self
.__class
__.network_id
))
448 def test_040_new_network_by_negative(self
):
449 self
.__class
__.network_name
= _get_random_string(20)
450 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
451 self
.__class
__.test_index
,
452 inspect
.currentframe().f_code
.co_name
)
453 self
.__class
__.test_index
+= 1
454 network
, _
= test_config
["vim_conn"].new_network(net_name
=self
.__class
__.network_name
,
455 net_type
='unknowntype')
456 self
.__class
__.network_id
= network
457 logger
.debug("{}".format(network
))
458 network_list
= test_config
["vim_conn"].get_network_list()
459 for net
in network_list
:
460 if self
.__class
__.network_name
in net
.get('name'):
461 self
.assertIn(self
.__class
__.network_name
, net
.get('name'))
463 # Deleting created network
464 result
= test_config
["vim_conn"].delete_network(self
.__class
__.network_id
)
466 logger
.info("Network id {} sucessfully deleted".format(self
.__class
__.network_id
))
468 logger
.info("Failed to delete network id {}".format(self
.__class
__.network_id
))
470 def test_050_refresh_nets_status(self
):
471 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
472 self
.__class
__.test_index
,
473 inspect
.currentframe().f_code
.co_name
)
474 self
.__class
__.test_index
+= 1
475 # creating new network
476 network_name
= _get_random_string(20)
478 network_id
, _
= test_config
["vim_conn"].new_network(net_name
=network_name
,
481 net_dict
= test_config
["vim_conn"].refresh_nets_status([network_id
])
482 for attr
in net_dict
[network_id
]:
484 self
.assertEqual(net_dict
[network_id
][attr
], 'ACTIVE')
486 # Deleting created network
487 result
= test_config
["vim_conn"].delete_network(network_id
)
489 logger
.info("Network id {} sucessfully deleted".format(network_id
))
491 logger
.info("Failed to delete network id {}".format(network_id
))
493 def test_060_refresh_nets_status_negative(self
):
494 unknown_net_id
= str(uuid
.uuid4())
495 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
496 self
.__class
__.test_index
,
497 inspect
.currentframe().f_code
.co_name
)
498 self
.__class
__.test_index
+= 1
501 net_dict
= test_config
["vim_conn"].refresh_nets_status([unknown_net_id
])
502 if test_config
['vimtype'] in ('openstack', 'azure'):
503 self
.assertEqual(net_dict
[unknown_net_id
]['status'], 'DELETED')
505 # TODO : Fix vmware connector to return status DELETED as per vimconn.py
506 self
.assertEqual(net_dict
, {})
508 class test_vimconn_get_network_list(test_base
):
512 # creating new network
513 self
.__class
__.network_name
= _get_random_string(20)
514 self
.__class
__.net_type
= 'bridge'
515 network
, _
= test_config
["vim_conn"].new_network(net_name
=self
.__class
__.network_name
,
516 net_type
=self
.__class
__.net_type
)
517 self
.__class
__.network_id
= network
518 logger
.debug("{}".format(network
))
521 test_base
.tearDown(self
)
523 # Deleting created network
524 result
= test_config
["vim_conn"].delete_network(self
.__class
__.network_id
)
526 logger
.info("Network id {} sucessfully deleted".format(self
.__class
__.network_id
))
528 logger
.info("Failed to delete network id {}".format(self
.__class
__.network_id
))
530 def test_000_get_network_list(self
):
531 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
532 self
.__class
__.test_index
,
533 inspect
.currentframe().f_code
.co_name
)
534 self
.__class
__.test_index
+= 1
536 network_list
= test_config
["vim_conn"].get_network_list()
537 for net
in network_list
:
538 if self
.__class
__.network_name
in net
.get('name'):
539 self
.assertIn(self
.__class
__.network_name
, net
.get('name'))
540 self
.assertEqual(net
.get('type'), self
.__class
__.net_type
)
541 self
.assertEqual(net
.get('status'), 'ACTIVE')
542 if test_config
['vimtype'] != 'azure':
543 self
.assertEqual(net
.get('shared'), False)
545 def test_010_get_network_list_by_name(self
):
546 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
547 self
.__class
__.test_index
,
548 inspect
.currentframe().f_code
.co_name
)
549 self
.__class
__.test_index
+= 1
551 if test_config
['vimtype'] in ('openstack', 'azure'):
552 network_name
= test_config
['vim_conn'].get_network(self
.__class
__.network_id
)['name']
554 network_name
= test_config
['vim_conn'].get_network_name_by_id(self
.__class
__.network_id
)
556 # find network from list by it's name
557 new_network_list
= test_config
["vim_conn"].get_network_list({'name': network_name
})
558 for list_item
in new_network_list
:
559 if self
.__class
__.network_name
in list_item
.get('name'):
560 self
.assertEqual(network_name
, list_item
.get('name'))
561 self
.assertEqual(list_item
.get('type'), self
.__class
__.net_type
)
562 self
.assertEqual(list_item
.get('status'), 'ACTIVE')
564 def test_020_get_network_list_by_id(self
):
565 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
566 self
.__class
__.test_index
,
567 inspect
.currentframe().f_code
.co_name
)
568 self
.__class
__.test_index
+= 1
570 # find network from list by it's id
571 new_network_list
= test_config
["vim_conn"].get_network_list({'id':self
.__class
__.network_id
})
572 for list_item
in new_network_list
:
573 if self
.__class
__.network_id
in list_item
.get('id'):
574 self
.assertEqual(self
.__class
__.network_id
, list_item
.get('id'))
575 self
.assertEqual(list_item
.get('type'), self
.__class
__.net_type
)
576 self
.assertEqual(list_item
.get('status'), 'ACTIVE')
578 def test_030_get_network_list_by_shared(self
):
580 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
581 self
.__class
__.test_index
,
582 inspect
.currentframe().f_code
.co_name
)
583 self
.__class
__.test_index
+= 1
585 if test_config
['vimtype'] in ('openstack', 'azure'):
586 network_name
= test_config
['vim_conn'].get_network(self
.__class
__.network_id
)['name']
588 network_name
= test_config
['vim_conn'].get_network_name_by_id(self
.__class
__.network_id
)
589 # find network from list by it's shared value
590 new_network_list
= test_config
["vim_conn"].get_network_list({'shared':Shared
,
591 'name':network_name
})
592 for list_item
in new_network_list
:
593 if list_item
.get('shared') == Shared
:
594 self
.assertEqual(list_item
.get('shared'), Shared
)
595 self
.assertEqual(list_item
.get('type'), self
.__class
__.net_type
)
596 self
.assertEqual(network_name
, list_item
.get('name'))
598 def test_040_get_network_list_by_tenant_id(self
):
599 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
600 self
.__class
__.test_index
,
601 inspect
.currentframe().f_code
.co_name
)
602 self
.__class
__.test_index
+= 1
604 tenant_list
= test_config
["vim_conn"].get_tenant_list()
605 if test_config
['vimtype'] in ('openstack', 'azure'):
606 network_name
= test_config
['vim_conn'].get_network(self
.__class
__.network_id
)['name']
608 network_name
= test_config
['vim_conn'].get_network_name_by_id(self
.__class
__.network_id
)
610 for tenant_item
in tenant_list
:
611 if test_config
['tenant'] == tenant_item
.get('name'):
612 # find network from list by it's tenant id
613 tenant_id
= tenant_item
.get('id')
614 new_network_list
= test_config
["vim_conn"].get_network_list({'tenant_id':tenant_id
,
615 'name':network_name
})
616 for list_item
in new_network_list
:
617 self
.assertEqual(tenant_id
, list_item
.get('tenant_id'))
618 self
.assertEqual(network_name
, list_item
.get('name'))
619 self
.assertEqual(list_item
.get('type'), self
.__class
__.net_type
)
620 self
.assertEqual(list_item
.get('status'), 'ACTIVE')
622 def test_050_get_network_list_by_status(self
):
623 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
624 self
.__class
__.test_index
,
625 inspect
.currentframe().f_code
.co_name
)
626 self
.__class
__.test_index
+= 1
629 if test_config
['vimtype'] in ('openstack', 'azure'):
630 network_name
= test_config
['vim_conn'].get_network(self
.__class
__.network_id
)['name']
632 network_name
= test_config
['vim_conn'].get_network_name_by_id(self
.__class
__.network_id
)
634 # find network from list by it's status
635 new_network_list
= test_config
["vim_conn"].get_network_list({'status':status
,
636 'name': network_name
})
637 for list_item
in new_network_list
:
638 self
.assertIn(self
.__class
__.network_name
, list_item
.get('name'))
639 self
.assertEqual(list_item
.get('type'), self
.__class
__.net_type
)
640 self
.assertEqual(list_item
.get('status'), status
)
642 def test_060_get_network_list_by_negative(self
):
643 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
644 self
.__class
__.test_index
,
645 inspect
.currentframe().f_code
.co_name
)
646 self
.__class
__.test_index
+= 1
648 network_list
= test_config
["vim_conn"].get_network_list({'name': 'unknown_name'})
649 self
.assertEqual(network_list
, [])
651 class test_vimconn_get_network(test_base
):
655 # creating new network
656 self
.__class
__.network_name
= _get_random_string(20)
657 self
.__class
__.net_type
= 'bridge'
658 network
, _
= test_config
["vim_conn"].new_network(net_name
=self
.__class
__.network_name
,
659 net_type
=self
.__class
__.net_type
)
660 self
.__class
__.network_id
= network
661 logger
.debug("{}".format(network
))
664 test_base
.tearDown(self
)
666 # Deleting created network
667 result
= test_config
["vim_conn"].delete_network(self
.__class
__.network_id
)
669 logger
.info("Network id {} sucessfully deleted".format(self
.__class
__.network_id
))
671 logger
.info("Failed to delete network id {}".format(self
.__class
__.network_id
))
673 def test_000_get_network(self
):
674 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
675 self
.__class
__.test_index
,
676 inspect
.currentframe().f_code
.co_name
)
677 self
.__class
__.test_index
+= 1
679 network_info
= test_config
["vim_conn"].get_network(self
.__class
__.network_id
)
680 self
.assertEqual(network_info
.get('status'), 'ACTIVE')
681 self
.assertIn(self
.__class
__.network_name
, network_info
.get('name'))
682 self
.assertEqual(network_info
.get('type'), self
.__class
__.net_type
)
683 self
.assertEqual(network_info
.get('id'), self
.__class
__.network_id
)
685 def test_010_get_network_negative(self
):
686 Non_exist_id
= str(uuid
.uuid4())
687 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
688 self
.__class
__.test_index
,
689 inspect
.currentframe().f_code
.co_name
)
690 self
.__class
__.test_index
+= 1
691 with self
.assertRaises(Exception) as context
:
692 test_config
["vim_conn"].get_network(Non_exist_id
)
694 self
.assertEqual((context
.exception
).http_code
, 404)
696 class test_vimconn_delete_network(test_base
):
699 def test_000_delete_network(self
):
701 self
.__class
__.network_name
= _get_random_string(20)
702 self
.__class
__.net_type
= 'bridge'
703 network
, _
= test_config
["vim_conn"].new_network(net_name
=self
.__class
__.network_name
,
704 net_type
=self
.__class
__.net_type
)
705 self
.__class
__.network_id
= network
706 logger
.debug("{}".format(network
))
708 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
709 self
.__class
__.test_index
,
710 inspect
.currentframe().f_code
.co_name
)
711 self
.__class
__.test_index
+= 1
713 result
= test_config
["vim_conn"].delete_network(self
.__class
__.network_id
)
715 logger
.info("Network id {} sucessfully deleted".format(self
.__class
__.network_id
))
717 logger
.info("Failed to delete network id {}".format(self
.__class
__.network_id
))
719 # after deleting network we check in network list
720 network_list
= test_config
["vim_conn"].get_network_list({ 'id':self
.__class
__.network_id
})
721 self
.assertEqual(network_list
, [])
723 def test_010_delete_network_negative(self
):
724 Non_exist_id
= str(uuid
.uuid4())
726 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
727 self
.__class
__.test_index
,
728 inspect
.currentframe().f_code
.co_name
)
729 self
.__class
__.test_index
+= 1
731 with self
.assertRaises(Exception) as context
:
732 test_config
["vim_conn"].delete_network(Non_exist_id
)
734 self
.assertEqual((context
.exception
).http_code
, 404)
736 class test_vimconn_get_flavor(test_base
):
738 def test_000_get_flavor(self
):
739 test_directory_content
= os
.listdir(test_config
["test_directory"])
741 for dir_name
in test_directory_content
:
742 if dir_name
== 'simple_linux':
743 self
.__class
__.scenario_test_path
= test_config
["test_directory"] + '/'+ dir_name
744 vnfd_files
= glob
.glob(self
.__class
__.scenario_test_path
+'/vnfd_*.yaml')
747 for vnfd
in vnfd_files
:
748 with
open(vnfd
, 'r') as stream
:
749 vnf_descriptor
= yaml
.load(stream
)
751 vnfc_list
= vnf_descriptor
['vnf']['VNFC']
752 for item
in vnfc_list
:
753 if 'ram' in item
and 'vcpus' in item
and 'disk' in item
:
755 vcpus
= item
['vcpus']
759 'name' : _get_random_string(20),
765 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
766 self
.__class
__.test_index
,
767 inspect
.currentframe().f_code
.co_name
)
768 self
.__class
__.test_index
+= 1
770 flavor_id
= test_config
["vim_conn"].new_flavor(flavor_data
)
772 result
= test_config
["vim_conn"].get_flavor(flavor_id
)
773 self
.assertEqual(ram
, result
['ram'])
774 self
.assertEqual(vcpus
, result
['vcpus'])
775 self
.assertEqual(disk
, result
['disk'])
778 result
= test_config
["vim_conn"].delete_flavor(flavor_id
)
780 logger
.info("Flavor id {} sucessfully deleted".format(result
))
782 logger
.info("Failed to delete flavor id {}".format(result
))
784 def test_010_get_flavor_negative(self
):
785 Non_exist_flavor_id
= str(uuid
.uuid4())
787 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
788 self
.__class
__.test_index
,
789 inspect
.currentframe().f_code
.co_name
)
790 self
.__class
__.test_index
+= 1
792 with self
.assertRaises(Exception) as context
:
793 test_config
["vim_conn"].get_flavor(Non_exist_flavor_id
)
795 self
.assertEqual((context
.exception
).http_code
, 404)
797 class test_vimconn_new_flavor(test_base
):
800 def test_000_new_flavor(self
):
801 flavor_data
= {'name': _get_random_string(20), 'ram': 1024, 'vcpus': 1, 'disk': 10}
803 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
804 self
.__class
__.test_index
,
805 inspect
.currentframe().f_code
.co_name
)
806 self
.__class
__.test_index
+= 1
809 self
.__class
__.flavor_id
= test_config
["vim_conn"].new_flavor(flavor_data
)
810 self
.assertIsInstance(self
.__class
__.flavor_id
, (str, unicode))
811 self
.assertIsInstance(uuid
.UUID(self
.__class
__.flavor_id
), uuid
.UUID
)
813 def test_010_delete_flavor(self
):
814 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
815 self
.__class
__.test_index
,
816 inspect
.currentframe().f_code
.co_name
)
817 self
.__class
__.test_index
+= 1
820 if test_config
['vimtype'] == 'azure':
821 with self
.assertRaises(Exception) as context
:
822 test_config
["vim_conn"].delete_flavor(self
.__class
__.flavor_id
)
824 self
.assertEqual((context
.exception
).http_code
, 401)
826 result
= test_config
["vim_conn"].delete_flavor(self
.__class
__.flavor_id
)
828 logger
.info("Flavor id {} sucessfully deleted".format(result
))
830 logger
.error("Failed to delete flavor id {}".format(result
))
831 raise Exception ("Failed to delete created flavor")
833 def test_020_new_flavor_negative(self
):
834 Invalid_flavor_data
= {'ram': '1024', 'vcpus': 2.0, 'disk': 2.0}
836 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
837 self
.__class
__.test_index
,
838 inspect
.currentframe().f_code
.co_name
)
839 self
.__class
__.test_index
+= 1
841 with self
.assertRaises(Exception) as context
:
842 test_config
["vim_conn"].new_flavor(Invalid_flavor_data
)
844 self
.assertEqual((context
.exception
).http_code
, 400)
846 def test_030_delete_flavor_negative(self
):
847 Non_exist_flavor_id
= str(uuid
.uuid4())
849 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
850 self
.__class
__.test_index
,
851 inspect
.currentframe().f_code
.co_name
)
852 self
.__class
__.test_index
+= 1
854 with self
.assertRaises(Exception) as context
:
855 test_config
["vim_conn"].delete_flavor(Non_exist_flavor_id
)
857 self
.assertEqual((context
.exception
).http_code
, 404)
859 # class test_vimconn_new_image(test_base):
861 # def test_000_new_image(self):
862 # self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
863 # self.__class__.test_index,
864 # inspect.currentframe().f_code.co_name)
865 # self.__class__.test_index += 1
867 # image_path = test_config['image_path']
869 # self.__class__.image_id = test_config["vim_conn"].new_image({ 'name': 'TestImage', 'location' : image_path, 'metadata': {'upload_location':None} })
872 # self.assertIsInstance(self.__class__.image_id, (str, unicode))
873 # self.assertIsInstance(uuid.UUID(self.__class__.image_id), uuid.UUID)
875 # self.skipTest("Skipping test as image file not present at RO container")
877 # def test_010_new_image_negative(self):
878 # Non_exist_image_path = '/temp1/cirros.ovf'
880 # self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
881 # self.__class__.test_index,
882 # inspect.currentframe().f_code.co_name)
883 # self.__class__.test_index += 1
885 # with self.assertRaises(Exception) as context:
886 # test_config["vim_conn"].new_image({ 'name': 'TestImage', 'location' : Non_exist_image_path})
888 # self.assertEqual((context.exception).http_code, 400)
890 # def test_020_delete_image(self):
891 # self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
892 # self.__class__.test_index,
893 # inspect.currentframe().f_code.co_name)
894 # self.__class__.test_index += 1
896 # image_id = test_config["vim_conn"].delete_image(self.__class__.image_id)
898 # self.assertIsInstance(image_id, (str, unicode))
900 # def test_030_delete_image_negative(self):
901 # Non_exist_image_id = str(uuid.uuid4())
903 # self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
904 # self.__class__.test_index,
905 # inspect.currentframe().f_code.co_name)
906 # self.__class__.test_index += 1
908 # with self.assertRaises(Exception) as context:
909 # test_config["vim_conn"].delete_image(Non_exist_image_id)
911 # self.assertEqual((context.exception).http_code, 404)
913 # class test_vimconn_get_image_id_from_path(test_base):
915 # def test_000_get_image_id_from_path(self):
916 # self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
917 # self.__class__.test_index,
918 # inspect.currentframe().f_code.co_name)
919 # self.__class__.test_index += 1
921 # image_path = test_config['image_path']
923 # image_id = test_config["vim_conn"].get_image_id_from_path( image_path )
924 # self.assertEqual(type(image_id),str)
926 # self.skipTest("Skipping test as image file not present at RO container")
928 # def test_010_get_image_id_from_path_negative(self):
929 # Non_exist_image_path = '/temp1/cirros.ovf'
931 # self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"],
932 # self.__class__.test_index,
933 # inspect.currentframe().f_code.co_name)
934 # self.__class__.test_index += 1
936 # with self.assertRaises(Exception) as context:
937 # test_config["vim_conn"].new_image({ 'name': 'TestImage', 'location' : Non_exist_image_path })
939 # self.assertEqual((context.exception).http_code, 400)
941 class test_vimconn_get_image_list(test_base
):
945 def test_000_get_image_list(self
):
946 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
947 self
.__class
__.test_index
,
948 inspect
.currentframe().f_code
.co_name
)
949 self
.__class
__.test_index
+= 1
951 # if test_config['image_name']:
952 # image_list = test_config['vim_conn'].get_image_list({'name': test_config['image_name']})
954 image_list
= test_config
["vim_conn"].get_image_list()
956 for item
in image_list
:
958 self
.__class
__.image_name
= item
['name']
959 self
.__class
__.image_id
= item
['id']
960 self
.assertIsInstance(self
.__class
__.image_name
, (str, unicode))
961 self
.assertIsInstance(self
.__class
__.image_id
, (str, unicode))
963 def test_010_get_image_list_by_name(self
):
964 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
965 self
.__class
__.test_index
,
966 inspect
.currentframe().f_code
.co_name
)
967 self
.__class
__.test_index
+= 1
969 image_list
= test_config
["vim_conn"].get_image_list({'name': self
.__class
__.image_name
})
971 for item
in image_list
:
972 self
.assertIsInstance(item
['id'], (str, unicode))
973 self
.assertIsInstance(item
['name'], (str, unicode))
974 self
.assertEqual(item
['id'], self
.__class
__.image_id
)
975 self
.assertEqual(item
['name'], self
.__class
__.image_name
)
977 def test_020_get_image_list_by_id(self
):
978 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
979 self
.__class
__.test_index
,
980 inspect
.currentframe().f_code
.co_name
)
981 self
.__class
__.test_index
+= 1
983 filter_image_list
= test_config
["vim_conn"].get_image_list({'id': self
.__class
__.image_id
})
985 for item1
in filter_image_list
:
986 self
.assertIsInstance(item1
['id'], (str, unicode))
987 self
.assertIsInstance(item1
['name'], (str, unicode))
988 self
.assertEqual(item1
['id'], self
.__class
__.image_id
)
989 self
.assertEqual(item1
['name'], self
.__class
__.image_name
)
991 def test_030_get_image_list_negative(self
):
992 Non_exist_image_id
= uuid
.uuid4()
993 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
994 self
.__class
__.test_index
,
995 inspect
.currentframe().f_code
.co_name
)
996 self
.__class
__.test_index
+= 1
997 image_list
= test_config
["vim_conn"].get_image_list({'name': 'Unknown_name', 'id': Non_exist_image_id
})
999 self
.assertIsNotNone(image_list
, None)
1000 self
.assertEqual(image_list
, [])
1002 class test_vimconn_new_vminstance(test_base
):
1011 self
.__class
__.network_name
= _get_random_string(20)
1012 self
.__class
__.net_type
= 'bridge'
1014 self
.__class
__.network_id
, _
= test_config
["vim_conn"].new_network(net_name
=self
.__class
__.network_name
,
1015 net_type
=self
.__class
__.net_type
)
1016 # find image name and image id
1017 if test_config
['image_name']:
1018 image_list
= test_config
['vim_conn'].get_image_list({'name': test_config
['image_name']})
1019 if len(image_list
) == 0:
1020 raise Exception("Image {} is not found at VIM".format(test_config
['image_name']))
1022 self
.__class
__.image_id
= image_list
[0]['id']
1024 image_list
= test_config
['vim_conn'].get_image_list()
1025 if len(image_list
) == 0:
1026 raise Exception("Not found any image at VIM")
1028 self
.__class
__.image_id
= image_list
[0]['id']
1031 test_base
.tearDown(self
)
1032 # Deleting created network
1033 result
= test_config
["vim_conn"].delete_network(self
.__class
__.network_id
)
1035 logger
.info("Network id {} sucessfully deleted".format(self
.__class
__.network_id
))
1037 logger
.info("Failed to delete network id {}".format(self
.__class
__.network_id
))
1039 def test_000_new_vminstance(self
):
1040 vpci
= "0000:00:11.0"
1043 flavor_data
= {'name': _get_random_string(20), 'ram': 1024, 'vcpus': 1, 'disk': 10}
1046 flavor_id
= test_config
["vim_conn"].new_flavor(flavor_data
)
1049 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1050 self
.__class
__.test_index
,
1051 inspect
.currentframe().f_code
.co_name
)
1052 self
.__class
__.test_index
+= 1
1054 net_list
= [{'use': self
.__class
__.net_type
, 'name': name
, 'floating_ip': False, 'vpci': vpci
,
1055 'port_security': True, 'type': 'virtual', 'net_id': self
.__class
__.network_id
}]
1057 self
.__class
__.instance_id
, _
= test_config
["vim_conn"].new_vminstance(name
='Test1_vm', description
='',
1059 image_id
=self
.__class
__.image_id
,
1060 flavor_id
=flavor_id
, net_list
=net_list
)
1062 self
.assertIsInstance(self
.__class
__.instance_id
, (str, unicode))
1064 def test_010_new_vminstance_by_model(self
):
1065 flavor_data
= {'name': _get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1066 model_name
= 'e1000'
1070 flavor_id
= test_config
["vim_conn"].new_flavor(flavor_data
)
1072 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1073 self
.__class
__.test_index
,
1074 inspect
.currentframe().f_code
.co_name
)
1075 self
.__class
__.test_index
+= 1
1077 net_list
= [{'use': self
.__class
__.net_type
, 'name': name
, 'floating_ip': False, 'port_security': True,
1078 'model': model_name
, 'type': 'virtual', 'net_id': self
.__class
__.network_id
}]
1080 instance_id
, _
= test_config
["vim_conn"].new_vminstance(name
='Test1_vm', description
='', start
=False,
1081 image_id
=self
.__class
__.image_id
,
1082 flavor_id
=flavor_id
,net_list
=net_list
)
1084 self
.assertIsInstance(instance_id
, (str, unicode))
1086 # Deleting created vm instance
1087 logger
.info("Deleting created vm intance")
1088 test_config
["vim_conn"].delete_vminstance(instance_id
)
1091 def test_020_new_vminstance_by_net_use(self
):
1092 flavor_data
= {'name': _get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1097 flavor_id
= test_config
["vim_conn"].new_flavor(flavor_data
)
1099 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1100 self
.__class
__.test_index
,
1101 inspect
.currentframe().f_code
.co_name
)
1102 self
.__class
__.test_index
+= 1
1104 net_list
= [{'use': net_use
, 'name': name
, 'floating_ip': False, 'port_security': True, 'type': 'virtual',
1105 'net_id': self
.__class
__.network_id
}]
1107 instance_id
, _
= test_config
["vim_conn"].new_vminstance(name
='Test1_vm', description
='', start
=False,
1108 image_id
=self
.__class
__.image_id
,disk_list
=None,
1109 flavor_id
=flavor_id
, net_list
=net_list
)
1110 self
.assertIsInstance(instance_id
, (str, unicode))
1112 # Deleting created vm instance
1113 logger
.info("Deleting created vm intance")
1114 test_config
["vim_conn"].delete_vminstance(instance_id
)
1117 def test_030_new_vminstance_by_net_type(self
):
1118 flavor_data
= {'name':_get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1123 flavor_id
= test_config
["vim_conn"].new_flavor(flavor_data
)
1125 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1126 self
.__class
__.test_index
,
1127 inspect
.currentframe().f_code
.co_name
)
1128 self
.__class
__.test_index
+= 1
1130 if test_config
['vimtype'] == 'vmware':
1131 net_list
= [{'use': self
.__class
__.net_type
, 'name': name
, 'floating_ip': False, 'port_security': True,
1132 'type': _type
, 'net_id': self
.__class
__.network_id
}]
1134 instance_id
, _
= test_config
["vim_conn"].new_vminstance(name
='Test1_vm', image_id
=self
.__class
__.image_id
,
1135 flavor_id
=flavor_id
,
1137 self
.assertEqual(type(instance_id
),str)
1139 if test_config
['vimtype'] in ('openstack', 'azure'):
1140 # create network of type data
1141 network_name
= _get_random_string(20)
1144 network_id
, _
= test_config
["vim_conn"].new_network(net_name
=network_name
,
1146 net_list
= [{'use': net_type
, 'name': name
, 'floating_ip': False, 'port_security': True,
1147 'type': _type
, 'net_id': network_id
}]
1149 instance_id
, _
= test_config
["vim_conn"].new_vminstance(name
='Test1_vm', description
='', start
=False,
1150 image_id
=self
.__class
__.image_id
, disk_list
=None,
1151 flavor_id
=flavor_id
,
1154 self
.assertEqual(type(instance_id
), unicode)
1156 # delete created network
1157 result
= test_config
["vim_conn"].delete_network(network_id
)
1159 logger
.info("Network id {} sucessfully deleted".format(network_id
))
1161 logger
.info("Failed to delete network id {}".format(network_id
))
1163 # Deleting created vm instance
1164 logger
.info("Deleting created vm intance")
1165 test_config
["vim_conn"].delete_vminstance(instance_id
)
1168 def test_040_new_vminstance_by_cloud_config(self
):
1169 flavor_data
= {'name': _get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1171 user_name
= 'test_user'
1173 key_pairs
= ['ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDtAjl5R+GSKP3gFrdFxgizKEUzhXKQbyjaxJH9thsK 0/fDiYlaNEjvijgPgiVZkfwvqgWeLprPcpzL2j4jvmmSJ3+7C8ihCwObWP0VUiuewmbIINBPAR0RqusjMRyPsa+q0asFBPOoZLx3Cv3vzmC1AA3mKuCNeT EuA0rlWhDIOVwMcU5sP1grnmuexQB8HcR7BdKcA9y08pTwnCQR8vmtW77SRkaxEGXm4Gnw5qw8Z27mHdk2wWS2SnbVH7aFwWvDXc6jjf5TpEWypdr/EAPC +eJipeS2Oa4FsntEqAu3Fz6gp/9ub8uNqgCgHfMzs6FhYpZpipwS0hXYyF6eVsSx osm@osm']
1175 users_data
= [{'key-pairs': ['ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDtAjl5R+GSKP3gFrdFxgizKEUzhXKQbyjaxJH9thsK0/fDiYlaNEjvijgPgiVZkfwvqgWeLprPcpzL2j4jvmmSJ3+7C8ihCwObWP0VUiuewmbIINBPAR0RqusjMRyPsa+q0asFBPOoZLx3Cv3vzmC1AA3mKuCNeTEuA0rlWhDIOVwMcU5sP1grnmuexQB8HcR7BdKcA9y08pTwnCQR8vmtW77SRkaxEGXm4Gnw5qw8Z27mHdk2wWS2SnbVH7aFwWvDXc6jjf5TpEWypdr/EAPC+eJipeS2Oa4FsntEqAu3Fz6gp/9ub8uNqgCgHfMzs6FhYpZpipwS0hXYyF6eVsSx osm@osm'], 'name': 'cloudinit'}]
1177 cloud_data
= {'config-files': [{'content': 'auto enp0s3\niface enp0s3 inet dhcp\n', 'dest': '/etc/network/interfaces.d/enp0s3.cfg', 'owner': 'root:root', 'permissions': '0644'}, {'content': '#! /bin/bash\nls -al >> /var/log/osm.log\n', 'dest': '/etc/rc.local', 'permissions': '0755'}, {'content': 'file content', 'dest': '/etc/test_delete'}], 'boot-data-drive': True, 'key-pairs': key_pairs
, 'users': users_data
}
1178 #cloud_data = {'users': users_data }
1181 flavor_id
= test_config
["vim_conn"].new_flavor(flavor_data
)
1183 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1184 self
.__class
__.test_index
,
1185 inspect
.currentframe().f_code
.co_name
)
1186 self
.__class
__.test_index
+= 1
1188 net_list
= [{'use': self
.__class
__.net_type
, 'name': name
, 'floating_ip': False, 'port_security': True,
1189 'type': 'virtual', 'net_id': self
.__class
__.network_id
}]
1191 instance_id
, _
= test_config
["vim_conn"].new_vminstance(name
='Cloud_vm', description
='', start
=False,
1192 image_id
=self
.__class
__.image_id
,
1193 flavor_id
=flavor_id
,net_list
=net_list
,
1194 cloud_config
=cloud_data
)
1196 self
.assertIsInstance(instance_id
, (str, unicode))
1198 # Deleting created vm instance
1199 logger
.info("Deleting created vm intance")
1200 test_config
["vim_conn"].delete_vminstance(instance_id
)
1203 def test_050_new_vminstance_by_disk_list(self
):
1204 flavor_data
= {'name':_get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1207 device_data
= [{'image_id': self
.__class
__.image_id
, 'size': '10'}]
1210 flavor_id
= test_config
["vim_conn"].new_flavor(flavor_data
)
1212 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1213 self
.__class
__.test_index
,
1214 inspect
.currentframe().f_code
.co_name
)
1215 self
.__class
__.test_index
+= 1
1217 net_list
= [{'use': self
.__class
__.net_type
, 'name': name
, 'floating_ip': False, 'port_security': True,
1218 'type': 'virtual', 'net_id': self
.__class
__.network_id
}]
1220 instance_id
, _
= test_config
["vim_conn"].new_vminstance(name
='VM_test1', description
='', start
=False,
1221 image_id
=self
.__class
__.image_id
,
1222 flavor_id
=flavor_id
, net_list
=net_list
,
1223 disk_list
=device_data
)
1225 self
.assertIsInstance(instance_id
, (str, unicode))
1226 # Deleting created vm instance
1227 logger
.info("Deleting created vm intance")
1228 test_config
["vim_conn"].delete_vminstance(instance_id
)
1231 def test_060_new_vminstance_negative(self
):
1232 unknown_flavor_id
= str(uuid
.uuid4())
1233 unknown_image_id
= str(uuid
.uuid4())
1236 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1237 self
.__class
__.test_index
,
1238 inspect
.currentframe().f_code
.co_name
)
1239 self
.__class
__.test_index
+= 1
1241 net_list
= [{'use': self
.__class
__.net_type
, 'name': name
, 'floating_ip': False, 'port_security': True,
1242 'type': 'virtual', 'net_id': self
.__class
__.network_id
}]
1244 with self
.assertRaises(Exception) as context
:
1245 test_config
["vim_conn"].new_vminstance(name
='Test1_vm', description
='', start
=False,
1246 image_id
=unknown_image_id
,
1247 flavor_id
=unknown_flavor_id
,
1250 self
.assertIn((context
.exception
).http_code
, (400, 404))
1253 def test_070_get_vminstance(self
):
1254 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1255 self
.__class
__.test_index
,
1256 inspect
.currentframe().f_code
.co_name
)
1257 self
.__class
__.test_index
+= 1
1259 # Get instance by its id
1260 vm_info
= test_config
["vim_conn"].get_vminstance(self
.__class
__.instance_id
)
1262 if test_config
['vimtype'] == 'vmware':
1263 for attr
in vm_info
:
1264 if attr
== 'status':
1265 self
.assertEqual(vm_info
[attr
], 'ACTIVE')
1266 if attr
== 'hostId':
1267 self
.assertEqual(type(vm_info
[attr
]), str)
1268 if attr
== 'interfaces':
1269 self
.assertEqual(type(vm_info
[attr
]), list)
1270 self
.assertEqual(vm_info
[attr
][0]['IsConnected'], 'true')
1271 if attr
== 'IsEnabled':
1272 self
.assertEqual(vm_info
[attr
], 'true')
1274 def test_080_get_vminstance_negative(self
):
1275 unknown_instance_id
= str(uuid
.uuid4())
1277 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1278 self
.__class
__.test_index
,
1279 inspect
.currentframe().f_code
.co_name
)
1280 self
.__class
__.test_index
+= 1
1282 with self
.assertRaises(Exception) as context
:
1283 test_config
["vim_conn"].get_vminstance(unknown_instance_id
)
1285 self
.assertEqual((context
.exception
).http_code
, 404)
1287 def test_090_refresh_vms_status(self
):
1288 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1289 self
.__class
__.test_index
,
1290 inspect
.currentframe().f_code
.co_name
)
1291 self
.__class
__.test_index
+= 1
1293 if test_config
['vimtype'] == 'vmware':
1295 vm_list
.append(self
.__class
__.instance_id
)
1298 vm_info
= test_config
["vim_conn"].refresh_vms_status(vm_list
)
1299 for attr
in vm_info
[self
.__class
__.instance_id
]:
1300 if attr
== 'status':
1301 self
.assertEqual(vm_info
[self
.__class
__.instance_id
][attr
], 'ACTIVE')
1302 if attr
== 'interfaces':
1303 self
.assertEqual(type(vm_info
[self
.__class
__.instance_id
][attr
]), list)
1305 if test_config
['vimtype'] in ('openstack', 'azure'):
1306 vpci
= "0000:00:11.0"
1309 flavor_data
= {'name': _get_random_string(20), 'ram': 1024, 'vcpus': 1, 'disk': 10}
1312 flavor_id
= test_config
["vim_conn"].new_flavor(flavor_data
)
1313 # create new vm instance
1314 net_list
= [{'use': self
.__class
__.net_type
, 'name': name
, 'floating_ip': False, 'vpci': vpci
,
1315 'port_security': True, 'type': 'virtual', 'net_id': self
.__class
__.network_id
}]
1317 instance_id
, _
= test_config
["vim_conn"].new_vminstance(name
='Test1_vm', description
='', start
=False,
1318 image_id
=self
.__class
__.image_id
,
1319 flavor_id
=flavor_id
, net_list
=net_list
)
1323 vm_list
.append(instance_id
)
1326 vm_info
= test_config
["vim_conn"].refresh_vms_status(vm_list
)
1327 for attr
in vm_info
[instance_id
]:
1328 if attr
== 'status':
1329 self
.assertEqual(vm_info
[instance_id
][attr
], 'ACTIVE')
1330 if attr
== 'interfaces':
1331 self
.assertEqual(type(vm_info
[instance_id
][attr
]), list)
1333 #Deleting created vm instance
1334 logger
.info("Deleting created vm intance")
1335 test_config
["vim_conn"].delete_vminstance(instance_id
)
1339 def test_100_refresh_vms_status_negative(self
):
1340 unknown_id
= str(uuid
.uuid4())
1342 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1343 self
.__class
__.test_index
,
1344 inspect
.currentframe().f_code
.co_name
)
1345 self
.__class
__.test_index
+= 1
1347 vm_dict
= test_config
["vim_conn"].refresh_vms_status([unknown_id
])
1349 if test_config
['vimtype'] == 'vmware':
1350 self
.assertEqual(vm_dict
,{})
1352 if test_config
['vimtype'] in ('openstack', 'azure'):
1353 self
.assertEqual(vm_dict
[unknown_id
]['status'], 'DELETED')
1355 def test_110_action_vminstance(self
):
1356 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1357 self
.__class
__.test_index
,
1358 inspect
.currentframe().f_code
.co_name
)
1359 self
.__class
__.test_index
+= 1
1361 if test_config
['vimtype'] == 'vmware':
1362 action_list
= ['shutdown', 'start', 'shutoff', 'rebuild', 'pause', 'resume']
1363 # various action on vminstace
1364 for action
in action_list
:
1365 instance_id
= test_config
["vim_conn"].action_vminstance(self
.__class
__.instance_id
,
1367 self
.assertEqual(instance_id
, self
.__class
__.instance_id
)
1369 if test_config
['vimtype'] in ('openstack', 'azure'):
1370 # create new vm instance
1371 vpci
= "0000:00:11.0"
1374 flavor_data
= {'name': _get_random_string(20), 'ram': 1024, 'vcpus': 1, 'disk': 10}
1377 flavor_id
= test_config
["vim_conn"].new_flavor(flavor_data
)
1379 net_list
= [{'use': self
.__class
__.net_type
, 'name': name
, 'floating_ip': False, 'vpci': vpci
,
1380 'port_security': True, 'type': 'virtual', 'net_id': self
.__class
__.network_id
}]
1382 new_instance_id
, _
= test_config
["vim_conn"].new_vminstance(name
='Test1_vm', description
='',
1383 start
=False, image_id
=self
.__class
__.image_id
,
1384 flavor_id
=flavor_id
, net_list
=net_list
)
1386 if test_config
['vimtype'] == 'openstack':
1387 action_list
= ['shutdown','start','shutoff','rebuild','start','pause','start']
1389 action_list
= ['shutdown','start','stop','start','shutoff','start','reboot']
1391 # various action on vminstace
1392 for action
in action_list
:
1393 # sleep for sometime till status is changed
1395 instance_id
= test_config
["vim_conn"].action_vminstance(new_instance_id
,
1398 self
.assertTrue(instance_id
is None)
1400 # Deleting created vm instance
1401 logger
.info("Deleting created vm intance")
1402 test_config
["vim_conn"].delete_vminstance(new_instance_id
)
1405 def test_120_action_vminstance_negative(self
):
1406 non_exist_id
= str(uuid
.uuid4())
1407 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1408 self
.__class
__.test_index
,
1409 inspect
.currentframe().f_code
.co_name
)
1410 self
.__class
__.test_index
+= 1
1413 with self
.assertRaises(Exception) as context
:
1414 test_config
["vim_conn"].action_vminstance(non_exist_id
, { action
: None})
1416 self
.assertEqual((context
.exception
).http_code
, 404)
1419 def test_130_delete_vminstance(self
):
1420 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1421 self
.__class
__.test_index
,
1422 inspect
.currentframe().f_code
.co_name
)
1423 self
.__class
__.test_index
+= 1
1425 # Deleting created vm instance
1426 logger
.info("Deleting created vm instance")
1427 test_config
["vim_conn"].delete_vminstance(self
.__class
__.instance_id
)
1430 def test_140_new_vminstance_sriov(self
):
1431 logger
.info("Testing creation of sriov vm instance using {}".format(test_config
['sriov_net_name']))
1432 flavor_data
= {'name': _get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10}
1436 flavor_id
= test_config
["vim_conn"].new_flavor(flavor_data
)
1438 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1439 self
.__class
__.test_index
,
1440 inspect
.currentframe().f_code
.co_name
)
1441 self
.__class
__.test_index
+= 1
1443 sriov_net_name
= test_config
['sriov_net_name']
1444 new_network_list
= test_config
["vim_conn"].get_network_list({'name': sriov_net_name
})
1445 for list_item
in new_network_list
:
1446 self
.assertEqual(sriov_net_name
, list_item
.get('name'))
1447 self
.__class
__.sriov_network_id
= list_item
.get('id')
1449 net_list
= [{'use': 'data', 'name': name
, 'floating_ip': False, 'port_security': True, 'type': 'VF',
1450 'net_id': self
.__class
__.sriov_network_id
}]
1452 instance_id
, _
= test_config
["vim_conn"].new_vminstance(name
='Test1_sriov_vm', description
='', start
=False,
1453 image_id
=self
.__class
__.image_id
, flavor_id
=flavor_id
,
1456 self
.assertIsInstance(instance_id
, (str, unicode))
1458 logger
.info("Waiting for created sriov-vm intance")
1460 # Deleting created vm instance
1461 logger
.info("Deleting created sriov-vm intance")
1462 test_config
["vim_conn"].delete_vminstance(instance_id
)
1465 class test_vimconn_get_tenant_list(test_base
):
1468 def test_000_get_tenant_list(self
):
1469 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1470 self
.__class
__.test_index
,
1471 inspect
.currentframe().f_code
.co_name
)
1472 self
.__class
__.test_index
+= 1
1474 # Getting tenant list
1475 tenant_list
= test_config
["vim_conn"].get_tenant_list()
1477 for item
in tenant_list
:
1478 if test_config
['tenant'] == item
['name']:
1479 self
.__class
__.tenant_id
= item
['id']
1480 self
.assertIsInstance(item
['name'], (str, unicode))
1481 self
.assertIsInstance(item
['id'], (str, unicode))
1483 def test_010_get_tenant_list_by_id(self
):
1484 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1485 self
.__class
__.test_index
,
1486 inspect
.currentframe().f_code
.co_name
)
1487 self
.__class
__.test_index
+= 1
1489 # Getting filter tenant list by its id
1490 filter_tenant_list
= test_config
["vim_conn"].get_tenant_list({'id': self
.__class
__.tenant_id
})
1492 for item
in filter_tenant_list
:
1493 self
.assertIsInstance(item
['id'], (str, unicode))
1494 self
.assertEqual(item
['id'], self
.__class
__.tenant_id
)
1496 def test_020_get_tenant_list_by_name(self
):
1497 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1498 self
.__class
__.test_index
,
1499 inspect
.currentframe().f_code
.co_name
)
1500 self
.__class
__.test_index
+= 1
1502 # Getting filter tenant list by its name
1503 filter_tenant_list
= test_config
["vim_conn"].get_tenant_list({'name': test_config
['tenant']})
1505 for item
in filter_tenant_list
:
1506 self
.assertIsInstance(item
['name'], (str, unicode))
1507 self
.assertEqual(item
['name'], test_config
['tenant'])
1509 def test_030_get_tenant_list_by_name_and_id(self
):
1510 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1511 self
.__class
__.test_index
,
1512 inspect
.currentframe().f_code
.co_name
)
1513 self
.__class
__.test_index
+= 1
1515 # Getting filter tenant list by its name and id
1516 filter_tenant_list
= test_config
["vim_conn"].get_tenant_list({'name': test_config
['tenant'],
1517 'id': self
.__class
__.tenant_id
})
1519 for item
in filter_tenant_list
:
1520 self
.assertIsInstance(item
['name'], (str, unicode))
1521 self
.assertIsInstance(item
['id'], (str, unicode))
1522 self
.assertEqual(item
['name'], test_config
['tenant'])
1523 self
.assertEqual(item
['id'], self
.__class
__.tenant_id
)
1525 def test_040_get_tenant_list_negative(self
):
1526 non_exist_tenant_name
= "Tenant_123"
1527 non_exist_tenant_id
= "kjhgrt456-45345kjhdfgnbdk-34dsfjdfg"
1528 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1529 self
.__class
__.test_index
,
1530 inspect
.currentframe().f_code
.co_name
)
1531 self
.__class
__.test_index
+= 1
1533 filter_tenant_list
= test_config
["vim_conn"].get_tenant_list({'name': non_exist_tenant_name
,
1534 'id': non_exist_tenant_id
})
1536 self
.assertEqual(filter_tenant_list
, [])
1539 class test_vimconn_new_tenant(test_base
):
1542 def test_000_new_tenant(self
):
1543 tenant_name
= _get_random_string(20)
1544 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1545 self
.__class
__.test_index
,
1546 inspect
.currentframe().f_code
.co_name
)
1547 self
.__class
__.test_index
+= 1
1549 if test_config
['vimtype'] != 'azure':
1550 self
.__class
__.tenant_id
= test_config
["vim_conn"].new_tenant(tenant_name
, "")
1553 self
.assertIsInstance(self
.__class
__.tenant_id
, (str, unicode))
1555 with self
.assertRaises(Exception) as context
:
1556 test_config
["vim_conn"].new_tenant(self
.__class
__.tenant_id
)
1557 self
.assertEqual((context
.exception
).http_code
, 401)
1560 def test_010_new_tenant_negative(self
):
1561 Invalid_tenant_name
= 10121
1562 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1563 self
.__class
__.test_index
,
1564 inspect
.currentframe().f_code
.co_name
)
1565 self
.__class
__.test_index
+= 1
1567 with self
.assertRaises(Exception) as context
:
1568 test_config
["vim_conn"].new_tenant(Invalid_tenant_name
, "")
1570 if test_config
['vimtype'] != 'azure':
1571 self
.assertEqual((context
.exception
).http_code
, 400)
1573 self
.assertEqual((context
.exception
).http_code
, 401)
1576 def test_020_delete_tenant(self
):
1577 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1578 self
.__class
__.test_index
,
1579 inspect
.currentframe().f_code
.co_name
)
1580 self
.__class
__.test_index
+= 1
1582 if test_config
['vimtype'] != 'azure':
1583 tenant_id
= test_config
["vim_conn"].delete_tenant(self
.__class
__.tenant_id
)
1584 self
.assertIsInstance(tenant_id
, (str, unicode))
1586 with self
.assertRaises(Exception) as context
:
1587 test_config
["vim_conn"].delete_tenant(self
.__class
__.tenant_id
)
1588 self
.assertEqual((context
.exception
).http_code
, 401)
1590 def test_030_delete_tenant_negative(self
):
1591 Non_exist_tenant_name
= 'Test_30_tenant'
1592 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1593 self
.__class
__.test_index
,
1594 inspect
.currentframe().f_code
.co_name
)
1595 self
.__class
__.test_index
+= 1
1597 with self
.assertRaises(Exception) as context
:
1598 test_config
["vim_conn"].delete_tenant(Non_exist_tenant_name
)
1600 self
.assertEqual((context
.exception
).http_code
, 404)
1604 if test_config
['image_name']:
1605 image_list
= test_config
['vim_conn'].get_image_list({'name': test_config
['image_name']})
1606 if len(image_list
) == 0:
1607 raise Exception("Image {} is not found at VIM".format(test_config
['image_name']))
1609 image_id
= image_list
[0]['id']
1611 image_list
= test_config
['vim_conn'].get_image_list()
1612 if len(image_list
) == 0:
1613 raise Exception("Not found any image at VIM")
1615 image_id
= image_list
[0]['id']
1619 class test_vimconn_vminstance_by_ip_address(test_base
):
1625 self
.network_name
= _get_random_string(20)
1627 self
.network_id
, _
= test_config
["vim_conn"].new_network(net_name
=self
.network_name
,
1631 test_base
.tearDown(self
)
1632 # Deleting created network
1633 result
= test_config
["vim_conn"].delete_network(self
.network_id
)
1635 logger
.info("Network id {} sucessfully deleted".format(self
.network_id
))
1637 logger
.info("Failed to delete network id {}".format(self
.network_id
))
1640 def test_000_vminstance_by_ip_address(self
):
1642 This test case will deploy VM with provided IP address
1643 Pre-requesite: provided IP address should be from IP pool range which has used for network creation
1646 # provide ip address
1649 flavor_data
= {'ram': 1024, 'vcpus': 1, 'disk': 10}
1652 flavor_id
= test_config
["vim_conn"].new_flavor(flavor_data
)
1655 image_id
= get_image_id()
1657 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1658 self
.__class
__.test_index
,
1659 inspect
.currentframe().f_code
.co_name
)
1660 self
.__class
__.test_index
+= 1
1662 net_list
= [{'use': 'bridge', 'name': name
, 'floating_ip': False, 'port_security': True, 'type': 'virtual',
1663 'net_id': self
.network_id
, 'ip_address': ip_address
}]
1665 instance_id
, _
= test_config
["vim_conn"].new_vminstance(name
='Test1_vm', image_id
=image_id
,
1666 flavor_id
=flavor_id
, net_list
=net_list
)
1668 self
.assertEqual(type(instance_id
),str)
1669 logger
.info("Deleting created vm instance")
1670 test_config
["vim_conn"].delete_vminstance(instance_id
)
1673 def test_010_vminstance_by_ip_address_negative(self
):
1675 # IP address not from subnet range
1676 invalid_ip_address
= '10.10.12.1'
1678 flavor_data
= {'ram': 1024, 'vcpus': 1, 'disk': 10}
1681 flavor_id
= test_config
["vim_conn"].new_flavor(flavor_data
)
1683 # find image name and image id
1684 image_id
= get_image_id()
1686 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1687 self
.__class
__.test_index
,
1688 inspect
.currentframe().f_code
.co_name
)
1689 self
.__class
__.test_index
+= 1
1691 net_list
= [{'use': 'bridge', 'name': name
, 'floating_ip': False, 'port_security': True, 'type': 'virtual',
1692 'net_id': self
.network_id
, 'ip_address': invalid_ip_address
}]
1694 with self
.assertRaises(Exception) as context
:
1695 test_config
["vim_conn"].new_vminstance(name
='Test1_vm', image_id
=image_id
,
1696 flavor_id
=flavor_id
,
1698 self
.assertEqual((context
.exception
).http_code
, 400)
1700 def test_020_vminstance_by_floating_ip(self
):
1702 flavor_data
= {'ram': 1024, 'vcpus': 1, 'disk': 10}
1705 flavor_id
= test_config
["vim_conn"].new_flavor(flavor_data
)
1707 # find image name and image id
1708 image_id
= get_image_id()
1710 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1711 self
.__class
__.test_index
,
1712 inspect
.currentframe().f_code
.co_name
)
1713 self
.__class
__.test_index
+= 1
1715 net_list
= [{'use': 'bridge', 'name': name
, 'floating_ip': True, 'port_security': True, 'type': 'virtual',
1716 'net_id': self
.network_id
}]
1718 instance_id
, _
= test_config
["vim_conn"].new_vminstance(name
='Test1_vm', image_id
=image_id
,
1719 flavor_id
=flavor_id
, net_list
=net_list
)
1721 self
.assertEqual(type(instance_id
),str)
1722 logger
.info("Deleting created vm instance")
1723 test_config
["vim_conn"].delete_vminstance(instance_id
)
1726 def test_030_vminstance_by_mac_address(self
):
1728 mac_address
= "74:54:2f:21:da:8c"
1729 flavor_data
= {'ram': 1024, 'vcpus': 1, 'disk': 10}
1732 flavor_id
= test_config
["vim_conn"].new_flavor(flavor_data
)
1734 # find image name and image id
1735 image_id
= get_image_id()
1737 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1738 self
.__class
__.test_index
,
1739 inspect
.currentframe().f_code
.co_name
)
1740 self
.__class
__.test_index
+= 1
1742 net_list
= [{'use': 'bridge', 'name': name
, 'floating_ip': False, 'port_security': True, 'type': 'virtual',
1743 'net_id': self
.network_id
,'mac_address': mac_address
}]
1745 instance_id
, _
= test_config
["vim_conn"].new_vminstance(name
='Test1_vm', image_id
=image_id
,
1746 flavor_id
=flavor_id
, net_list
=net_list
)
1748 self
.assertEqual(type(instance_id
),str)
1749 logger
.info("Deleting created vm instance")
1750 test_config
["vim_conn"].delete_vminstance(instance_id
)
1753 class test_vimconn_vminstance_by_adding_10_nics(test_base
):
1761 self
.network_name
= _get_random_string(20)
1762 network_id
, _
= test_config
["vim_conn"].new_network(net_name
=self
.network_name
,
1764 self
.net_ids
.append(network_id
)
1767 test_base
.tearDown(self
)
1768 # Deleting created network
1769 for net_id
in self
.net_ids
:
1770 result
= test_config
["vim_conn"].delete_network(net_id
)
1772 logger
.info("Network id {} sucessfully deleted".format(net_id
))
1774 logger
.info("Failed to delete network id {}".format(net_id
))
1776 def test_000_vminstance_by_adding_10_nics(self
):
1777 flavor_data
= {'ram': 1024, 'vcpus': 1, 'disk': 10}
1780 flavor_id
= test_config
["vim_conn"].new_flavor(flavor_data
)
1782 # find image name and image id
1783 image_id
= get_image_id()
1785 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1786 self
.__class
__.test_index
,
1787 inspect
.currentframe().f_code
.co_name
)
1788 self
.__class
__.test_index
+= 1
1792 for net_id
in self
.net_ids
:
1793 name
= "eth{}".format(c
)
1794 net_list
.append({'use': 'bridge', 'name': name
, 'floating_ip': False,
1795 'port_security': True, 'type': 'virtual', 'net_id': net_id
})
1798 instance_id
, _
= test_config
["vim_conn"].new_vminstance(name
='Test1_vm', image_id
=image_id
,
1799 flavor_id
=flavor_id
, net_list
=net_list
)
1801 self
.assertEqual(type(instance_id
),str)
1802 logger
.info("Deleting created vm instance")
1803 test_config
["vim_conn"].delete_vminstance(instance_id
)
1807 class test_vimconn_vminstance_by_existing_disk(test_base
):
1813 self
.network_name
= _get_random_string(20)
1814 self
.network_id
, _
= test_config
["vim_conn"].new_network(net_name
=self
.network_name
,
1818 test_base
.tearDown(self
)
1819 # Deleting created network
1820 result
= test_config
["vim_conn"].delete_network(self
.network_id
)
1822 logger
.info("Network id {} sucessfully deleted".format(self
.network_id
))
1824 logger
.info("Failed to delete network id {}".format(self
.network_id
))
1827 def test_000_vminstance_by_existing_disk(self
):
1828 """ This testcase will add existing disk only if given catalog/image is free
1829 means not used by any other VM
1832 flavor_data
= {'ram': 1024, 'vcpus': 1, 'disk': 10}
1836 flavor_id
= test_config
["vim_conn"].new_flavor(flavor_data
)
1838 # find image name and image id
1839 image_id
= get_image_id()
1840 cirros_image
= test_config
["vim_conn"].get_image_list({'name': 'cirros'})
1841 disk_list
= [{'image_id': cirros_image
[0]['id'],'size': 5}]
1843 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1844 self
.__class
__.test_index
,
1845 inspect
.currentframe().f_code
.co_name
)
1846 self
.__class
__.test_index
+= 1
1848 net_list
= [{'use': 'bridge', 'name': name
, 'floating_ip': False, 'port_security': True,
1849 'type': 'virtual', 'net_id': self
.network_id
}]
1851 instance_id
, _
= test_config
["vim_conn"].new_vminstance(name
='Test1_vm', description
='', start
=False,
1853 flavor_id
=flavor_id
, net_list
=net_list
,disk_list
=disk_list
)
1855 self
.assertEqual(type(instance_id
),str)
1856 logger
.info("Deleting created vm instance")
1857 test_config
["vim_conn"].delete_vminstance(instance_id
)
1860 def test_010_vminstance_by_new_disk(self
):
1861 flavor_data
= {'ram': 1024, 'vcpus': 1, 'disk': 10}
1865 flavor_id
= test_config
["vim_conn"].new_flavor(flavor_data
)
1867 # find image name and image id
1868 image_id
= get_image_id()
1869 disk_list
= [{'size': '5'}]
1871 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1872 self
.__class
__.test_index
,
1873 inspect
.currentframe().f_code
.co_name
)
1874 self
.__class
__.test_index
+= 1
1876 net_list
= [{'use': 'bridge', 'name': name
, 'floating_ip': False, 'port_security': True,
1877 'type': 'virtual', 'net_id': self
.network_id
}]
1879 instance_id
, _
= test_config
["vim_conn"].new_vminstance(name
='Test1_vm', description
='', start
=False,
1881 flavor_id
=flavor_id
, net_list
=net_list
,disk_list
=disk_list
)
1883 self
.assertEqual(type(instance_id
),str)
1884 logger
.info("Deleting created vm instance")
1885 test_config
["vim_conn"].delete_vminstance(instance_id
)
1888 def test_020_vminstance_by_CDROM(self
):
1889 """ This testcase will insert media file only if provided catalog
1890 has pre-created ISO media file into vCD
1892 flavor_data
={'ram': 1024, 'vcpus': 1, 'disk': 10}
1894 image_list
= test_config
["vim_conn"].get_image_list({'name':'Ubuntu'})
1895 disk_list
= [{'image_id':image_list
[0]['id'],'device_type':'cdrom'}]
1898 flavor_id
= test_config
["vim_conn"].new_flavor(flavor_data
)
1900 # find image name and image id
1901 image_id
= get_image_id()
1903 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1904 self
.__class
__.test_index
,
1905 inspect
.currentframe().f_code
.co_name
)
1906 self
.__class
__.test_index
+= 1
1908 net_list
= [{'use': 'bridge', 'name': name
, 'floating_ip': False, 'port_security': True,
1909 'type': 'virtual', 'net_id': self
.network_id
}]
1911 instance_id
, _
= test_config
["vim_conn"].new_vminstance(name
='Test1_vm', description
='', start
=False,
1913 flavor_id
=flavor_id
, net_list
=net_list
,disk_list
=disk_list
)
1915 self
.assertEqual(type(instance_id
),str)
1916 logger
.info("Deleting created vm instance")
1917 test_config
["vim_conn"].delete_vminstance(instance_id
)
1921 class test_vimconn_vminstance_by_affinity_anti_affinity(test_base
):
1927 self
.network_name
= _get_random_string(20)
1928 self
.network_id
, _
= test_config
["vim_conn"].new_network(net_name
=self
.network_name
,
1932 test_base
.tearDown(self
)
1933 # Deleting created network
1934 result
= test_config
["vim_conn"].delete_network(self
.network_id
)
1936 logger
.info("Network id {} sucessfully deleted".format(self
.network_id
))
1938 logger
.info("Failed to delete network id {}".format(self
.network_id
))
1940 def test_000_vminstance_by_affinity_anti_affinity(self
):
1941 """ This testcase will deploy VM into provided HOSTGROUP in VIM config
1942 Pre-requisites: User has created Hosh Groups in vCenter with respective Hosts to be used
1943 While creating VIM account user has to pass the Host Group names in availability_zone list
1945 flavor_data
= {'ram': 1024, 'vcpus': 1, 'disk': 10}
1949 flavor_id
= test_config
["vim_conn"].new_flavor(flavor_data
)
1951 # find image name and image id
1952 image_id
= get_image_id()
1954 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
1955 self
.__class
__.test_index
,
1956 inspect
.currentframe().f_code
.co_name
)
1957 self
.__class
__.test_index
+= 1
1959 net_list
= [{'use': 'bridge', 'name': name
, 'floating_ip': False, 'port_security': True,
1960 'type': 'virtual', 'net_id': self
.network_id
}]
1962 instance_id
, _
= test_config
["vim_conn"].new_vminstance(name
='Test1_vm', description
='', start
=False,
1964 flavor_id
=flavor_id
, net_list
=net_list
,availability_zone_index
=1,
1965 availability_zone_list
=['HG_174','HG_175'])
1967 self
.assertEqual(type(instance_id
),str)
1969 logger
.info("Deleting created vm instance")
1970 test_config
["vim_conn"].delete_vminstance(instance_id
)
1972 class test_vimconn_vminstance_by_numa_affinity(test_base
):
1978 self
.network_name
= _get_random_string(20)
1979 self
.network_id
, _
= test_config
["vim_conn"].new_network(net_name
=self
.network_name
,
1983 test_base
.tearDown(self
)
1984 # Deleting created network
1985 result
= test_config
["vim_conn"].delete_network(self
.network_id
)
1987 logger
.info("Network id {} sucessfully deleted".format(self
.network_id
))
1989 logger
.info("Failed to delete network id {}".format(self
.network_id
))
1991 def test_000_vminstance_by_numa_affinity(self
):
1992 flavor_data
= {'extended': {'numas': [{'paired-threads-id': [['1', '3'], ['2', '4']],
1993 ' paired-threads': 2, 'memory': 1}]},
1994 'ram': 1024, 'vcpus': 1, 'disk': 10}
1998 flavor_id
= test_config
["vim_conn"].new_flavor(flavor_data
)
2000 # find image name and image id
2001 image_id
= get_image_id()
2003 self
.__class
__.test_text
= "{}.{}. TEST {}".format(test_config
["test_number"],
2004 self
.__class
__.test_index
,
2005 inspect
.currentframe().f_code
.co_name
)
2006 self
.__class
__.test_index
+= 1
2008 net_list
= [{'use': 'bridge', 'name': name
, 'floating_ip': False, 'port_security': True,
2009 'type': 'virtual', 'net_id': self
.network_id
}]
2011 instance_id
, _
= test_config
["vim_conn"].new_vminstance(name
='Test1_vm', description
='', start
=False,
2013 flavor_id
=flavor_id
, net_list
=net_list
)
2015 self
.assertEqual(type(instance_id
),str)
2016 logger
.info("Deleting created vm instance")
2017 test_config
["vim_conn"].delete_vminstance(instance_id
)
2023 The following unittest class does not have the 'test_' on purpose. This test is the one used for the
2024 scenario based tests.
2026 class descriptor_based_scenario_test(test_base
):
2028 scenario_test_path
= None
2031 def setUpClass(cls
):
2033 cls
.to_delete_list
= []
2034 cls
.scenario_uuids
= []
2035 cls
.instance_scenario_uuids
= []
2036 cls
.scenario_test_path
= test_config
["test_directory"] + '/' + test_config
["test_folder"]
2037 logger
.info("{}. {} {}".format(test_config
["test_number"], cls
.__name
__, test_config
["test_folder"]))
2040 def tearDownClass(cls
):
2041 test_config
["test_number"] += 1
2043 def test_000_load_scenario(self
):
2044 self
.__class
__.test_text
= "{}.{}. TEST {} {}".format(test_config
["test_number"], self
.__class
__.test_index
,
2045 inspect
.currentframe().f_code
.co_name
,
2046 test_config
["test_folder"])
2047 self
.__class
__.test_index
+= 1
2049 descriptor_files
= glob
.glob(self
.__class
__.scenario_test_path
+'/*.yaml')
2050 vnf_descriptors
= []
2051 scenario_descriptors
= []
2052 for descriptor_file
in descriptor_files
:
2053 with
open(descriptor_file
, 'r') as stream
:
2054 descriptor
= yaml
.load(stream
)
2055 if "vnf" in descriptor
or "vnfd:vnfd-catalog" in descriptor
or "vnfd-catalog" in descriptor
:
2056 vnf_descriptors
.append(descriptor
)
2058 scenario_descriptors
.append(descriptor
)
2060 scenario_file
= glob
.glob(self
.__class
__.scenario_test_path
+ '/scenario_*.yaml')
2061 if not vnf_descriptors
or not scenario_descriptors
or len(scenario_descriptors
) > 1:
2062 raise Exception("Test '{}' not valid. It must contain an scenario file and at least one vnfd file'".format(
2063 test_config
["test_folder"]))
2066 for vnf_descriptor
in vnf_descriptors
:
2067 logger
.debug("VNF descriptor: {}".format(vnf_descriptor
))
2068 vnf
= test_config
["client"].create_vnf(descriptor
=vnf_descriptor
, image_name
=test_config
["image_name"])
2071 vnf_uuid
= vnf
['vnf']['uuid']
2073 vnf_uuid
= vnf
['vnfd'][0]['uuid']
2074 self
.__class
__.to_delete_list
.insert(0, {"item": "vnf", "function": test_config
["client"].delete_vnf
,
2075 "params": {"uuid": vnf_uuid
}})
2077 # load the scenario definition
2078 for scenario_descriptor
in scenario_descriptors
:
2079 # networks = scenario_descriptor['scenario']['networks']
2080 # networks[test_config["mgmt_net"]] = networks.pop('mgmt')
2081 logger
.debug("Scenario descriptor: {}".format(scenario_descriptor
))
2082 scenario
= test_config
["client"].create_scenario(descriptor
=scenario_descriptor
)
2083 logger
.debug(scenario
)
2084 if 'scenario' in scenario
:
2085 scenario_uuid
= scenario
['scenario']['uuid']
2087 scenario_uuid
= scenario
['nsd'][0]['uuid']
2088 self
.__class
__.to_delete_list
.insert(0, {"item": "scenario",
2089 "function": test_config
["client"].delete_scenario
,
2090 "params": {"uuid": scenario_uuid
}})
2091 self
.__class
__.scenario_uuids
.append(scenario_uuid
)
2093 def test_010_instantiate_scenario(self
):
2094 self
.__class
__.test_text
= "{}.{}. TEST {} {}".format(test_config
["test_number"], self
.__class
__.test_index
,
2095 inspect
.currentframe().f_code
.co_name
,
2096 test_config
["test_folder"])
2097 self
.__class
__.test_index
+= 1
2098 for scenario_uuid
in self
.__class
__.scenario_uuids
:
2099 instance_descriptor
= {
2101 "name": self
.__class
__.test_text
,
2102 "scenario": scenario_uuid
,
2104 "mgmt": {"sites": [ { "netmap-use": test_config
["mgmt_net"]} ]}
2108 instance
= test_config
["client"].create_instance(instance_descriptor
)
2109 self
.__class
__.instance_scenario_uuids
.append(instance
['uuid'])
2110 logger
.debug(instance
)
2111 self
.__class
__.to_delete_list
.insert(0, {"item": "instance",
2112 "function": test_config
["client"].delete_instance
,
2113 "params": {"uuid": instance
['uuid']}})
2115 def test_020_check_deployent(self
):
2116 self
.__class
__.test_text
= "{}.{}. TEST {} {}".format(test_config
["test_number"], self
.__class
__.test_index
,
2117 inspect
.currentframe().f_code
.co_name
,
2118 test_config
["test_folder"])
2119 self
.__class
__.test_index
+= 1
2121 if test_config
["manual"]:
2122 raw_input('Scenario has been deployed. Perform manual check and press any key to resume')
2125 keep_waiting
= test_config
["timeout"]
2126 pending_instance_scenario_uuids
= list(self
.__class
__.instance_scenario_uuids
) # make a copy
2127 while pending_instance_scenario_uuids
:
2129 while index
< len(pending_instance_scenario_uuids
):
2130 result
= check_instance_scenario_active(pending_instance_scenario_uuids
[index
])
2132 del pending_instance_scenario_uuids
[index
]
2134 elif 'ERROR' in result
[1]:
2135 msg
= 'Got error while waiting for the instance to get active: '+result
[1]
2137 raise Exception(msg
)
2140 if keep_waiting
>= 5:
2143 elif keep_waiting
> 0:
2144 time
.sleep(keep_waiting
)
2147 msg
= 'Timeout reached while waiting instance scenario to get active'
2149 raise Exception(msg
)
2151 def test_030_clean_deployment(self
):
2152 self
.__class
__.test_text
= "{}.{}. TEST {} {}".format(test_config
["test_number"], self
.__class
__.test_index
,
2153 inspect
.currentframe().f_code
.co_name
,
2154 test_config
["test_folder"])
2155 self
.__class
__.test_index
+= 1
2156 #At the moment if you delete an scenario right after creating it, in openstack datacenters
2157 #sometimes scenario ports get orphaned. This sleep is just a dirty workaround
2159 for item
in self
.__class
__.to_delete_list
:
2160 response
= item
["function"](**item
["params"])
2161 logger
.debug(response
)
2164 def _get_random_string(maxLength
):
2165 '''generates a string with random characters string.letters and string.digits
2166 with a random length up to maxLength characters. If maxLength is <15 it will be changed automatically to 15
2170 minLength
= min_string
- len(prefix
)
2171 if maxLength
< min_string
: maxLength
= min_string
2172 maxLength
-= len(prefix
)
2173 length
= random
.randint(minLength
,maxLength
)
2174 return 'testing_'+"".join([random
.choice(string
.letters
+string
.digits
) for i
in xrange(length
)])
2177 def test_vimconnector(args
):
2179 sys
.path
.append(os
.path
.dirname(os
.path
.dirname(os
.path
.abspath(__file__
))) + "/osm_ro")
2180 test_config
['vimtype'] = args
.vimtype
2181 if args
.vimtype
== "vmware":
2182 import vimconn_vmware
as vim
2184 test_config
["test_directory"] = os
.path
.dirname(__file__
) + "/RO_tests"
2186 tenant_name
= args
.tenant_name
2187 test_config
['tenant'] = tenant_name
2188 config_params
= yaml
.load(args
.config_param
)
2189 org_name
= config_params
.get('orgname')
2190 org_user
= config_params
.get('user')
2191 org_passwd
= config_params
.get('passwd')
2192 vim_url
= args
.endpoint_url
2193 test_config
['image_path'] = args
.image_path
2194 test_config
['image_name'] = args
.image_name
2195 test_config
['sriov_net_name'] = args
.sriov_net_name
2197 # vmware connector obj
2198 test_config
['vim_conn'] = vim
.vimconnector(name
=org_name
, tenant_name
=tenant_name
, user
=org_user
,
2199 passwd
=org_passwd
, url
=vim_url
, config
=config_params
)
2201 elif args
.vimtype
== "aws":
2202 import vimconn_aws
as vim
2203 elif args
.vimtype
== "openstack":
2204 import vimconn_openstack
as vim
2206 test_config
["test_directory"] = os
.path
.dirname(__file__
) + "/RO_tests"
2208 tenant_name
= args
.tenant_name
2209 test_config
['tenant'] = tenant_name
2210 config_params
= yaml
.load(args
.config_param
)
2211 os_user
= config_params
.get('user')
2212 os_passwd
= config_params
.get('passwd')
2213 vim_url
= args
.endpoint_url
2214 test_config
['image_path'] = args
.image_path
2215 test_config
['image_name'] = args
.image_name
2216 test_config
['sriov_net_name'] = args
.sriov_net_name
2218 # openstack connector obj
2219 vim_persistent_info
= {}
2220 test_config
['vim_conn'] = vim
.vimconnector(
2221 uuid
="test-uuid-1", name
="VIO-openstack",
2222 tenant_id
=None, tenant_name
=tenant_name
,
2223 url
=vim_url
, url_admin
=None,
2224 user
=os_user
, passwd
=os_passwd
,
2225 config
=config_params
, persistent_info
=vim_persistent_info
2227 test_config
['vim_conn'].debug
= "true"
2229 elif args
.vimtype
== "openvim":
2230 import vimconn_openvim
as vim
2231 elif args
.vimtype
== "azure":
2232 import vimconn_azure
as vim
2234 test_config
["test_directory"] = os
.path
.dirname(__file__
) + "/RO_tests"
2236 tenant_name
= args
.tenant_name
2237 test_config
['tenant'] = tenant_name
2238 config_params
= yaml
.load(args
.config_param
)
2239 os_user
= config_params
.get('user')
2240 os_passwd
= config_params
.get('passwd')
2241 vim_url
= args
.endpoint_url
2242 test_config
['image_path'] = args
.image_path
2243 test_config
['image_name'] = args
.image_name
2244 #test_config['sriov_net_name'] = args.sriov_net_name
2246 # azure connector obj
2247 vim_persistent_info
= {}
2248 test_config
['vim_conn'] = vim
.vimconnector(
2249 uuid
="test-uuid-1", name
="VIO-azure",
2250 tenant_id
=None, tenant_name
=tenant_name
,
2251 url
=vim_url
, url_admin
=None,
2252 user
=os_user
, passwd
=os_passwd
,
2253 config
=config_params
, persistent_info
=vim_persistent_info
2255 test_config
['vim_conn'].debug
= "true"
2258 logger
.critical("vimtype '{}' not supported".format(args
.vimtype
))
2262 clsmembers
= inspect
.getmembers(sys
.modules
[__name__
], inspect
.isclass
)
2263 # If only want to obtain a tests list print it and exit
2266 for cls
in clsmembers
:
2267 if cls
[0].startswith('test_vimconn'):
2268 tests_names
.append(cls
[0])
2270 msg
= "The 'vim' set tests are:\n\t" + ', '.join(sorted(tests_names
))
2275 # Create the list of tests to be run
2276 code_based_tests
= []
2278 for test
in args
.tests
:
2279 for t
in test
.split(','):
2280 matches_code_based_tests
= [item
for item
in clsmembers
if item
[0] == t
]
2281 if len(matches_code_based_tests
) > 0:
2282 code_based_tests
.append(matches_code_based_tests
[0][1])
2284 logger
.critical("Test '{}' is not among the possible ones".format(t
))
2286 if not code_based_tests
:
2288 for cls
in clsmembers
:
2289 # We exclude 'test_VIM_tenant_operations' unless it is specifically requested by the user
2290 if cls
[0].startswith('test_vimconn'):
2291 code_based_tests
.append(cls
[1])
2293 logger
.debug("tests to be executed: {}".format(code_based_tests
))
2295 # TextTestRunner stream is set to /dev/null in order to avoid the method to directly print the result of tests.
2296 # This is handled in the tests using logging.
2297 stream
= open('/dev/null', 'w')
2299 # Run code based tests
2300 basic_tests_suite
= unittest
.TestSuite()
2301 for test
in code_based_tests
:
2302 basic_tests_suite
.addTest(unittest
.makeSuite(test
))
2303 result
= unittest
.TextTestRunner(stream
=stream
, failfast
=failfast
).run(basic_tests_suite
)
2304 executed
+= result
.testsRun
2305 failed
+= len(result
.failures
) + len(result
.errors
)
2306 if failfast
and failed
:
2308 if len(result
.failures
) > 0:
2309 logger
.debug("failures : {}".format(result
.failures
))
2310 if len(result
.errors
) > 0:
2311 logger
.debug("errors : {}".format(result
.errors
))
2312 return executed
, failed
2317 sys
.path
.append(os
.path
.dirname(os
.path
.dirname(os
.path
.abspath(__file__
))) + "/osm_ro")
2318 import openmanoclient
2321 test_config
["client"] = openmanoclient
.openmanoclient(
2322 endpoint_url
=args
.endpoint_url
,
2323 tenant_name
=args
.tenant_name
,
2324 datacenter_name
=args
.datacenter
,
2325 debug
=args
.debug
, logger
=test_config
["logger_name"])
2326 clsmembers
= inspect
.getmembers(sys
.modules
[__name__
], inspect
.isclass
)
2327 # If only want to obtain a tests list print it and exit
2330 for cls
in clsmembers
:
2331 if cls
[0].startswith('test_VIM'):
2332 tests_names
.append(cls
[0])
2334 msg
= "The 'vim' set tests are:\n\t" + ', '.join(sorted(tests_names
)) +\
2335 "\nNOTE: The test test_VIM_tenant_operations will fail in case the used datacenter is type OpenStack " \
2336 "unless RO has access to the admin endpoint. Therefore this test is excluded by default"
2341 # Create the list of tests to be run
2342 code_based_tests
= []
2344 for test
in args
.tests
:
2345 for t
in test
.split(','):
2346 matches_code_based_tests
= [item
for item
in clsmembers
if item
[0] == t
]
2347 if len(matches_code_based_tests
) > 0:
2348 code_based_tests
.append(matches_code_based_tests
[0][1])
2350 logger
.critical("Test '{}' is not among the possible ones".format(t
))
2352 if not code_based_tests
:
2354 for cls
in clsmembers
:
2355 # We exclude 'test_VIM_tenant_operations' unless it is specifically requested by the user
2356 if cls
[0].startswith('test_VIM') and cls
[0] != 'test_VIM_tenant_operations':
2357 code_based_tests
.append(cls
[1])
2359 logger
.debug("tests to be executed: {}".format(code_based_tests
))
2361 # TextTestRunner stream is set to /dev/null in order to avoid the method to directly print the result of tests.
2362 # This is handled in the tests using logging.
2363 stream
= open('/dev/null', 'w')
2365 # Run code based tests
2366 basic_tests_suite
= unittest
.TestSuite()
2367 for test
in code_based_tests
:
2368 basic_tests_suite
.addTest(unittest
.makeSuite(test
))
2369 result
= unittest
.TextTestRunner(stream
=stream
, failfast
=failfast
).run(basic_tests_suite
)
2370 executed
+= result
.testsRun
2371 failed
+= len(result
.failures
) + len(result
.errors
)
2372 if failfast
and failed
:
2374 if len(result
.failures
) > 0:
2375 logger
.debug("failures : {}".format(result
.failures
))
2376 if len(result
.errors
) > 0:
2377 logger
.debug("errors : {}".format(result
.errors
))
2378 return executed
, failed
2383 sys
.path
.append(os
.path
.dirname(os
.path
.dirname(os
.path
.abspath(__file__
))) + "/osm_ro")
2384 import openmanoclient
2387 test_config
["client"] = openmanoclient
.openmanoclient(
2388 endpoint_url
=args
.endpoint_url
,
2389 tenant_name
=args
.tenant_name
,
2390 datacenter_name
=args
.datacenter
,
2391 debug
=args
.debug
, logger
=test_config
["logger_name"])
2392 clsmembers
= inspect
.getmembers(sys
.modules
[__name__
], inspect
.isclass
)
2393 # If only want to obtain a tests list print it and exit
2396 for cls
in clsmembers
:
2397 if cls
[0].startswith('test_WIM'):
2398 tests_names
.append(cls
[0])
2400 msg
= "The 'wim' set tests are:\n\t" + ', '.join(sorted(tests_names
)) +\
2401 "\nNOTE: The test test_VIM_tenant_operations will fail in case the used datacenter is type OpenStack " \
2402 "unless RO has access to the admin endpoint. Therefore this test is excluded by default"
2407 # Create the list of tests to be run
2408 code_based_tests
= []
2410 for test
in args
.tests
:
2411 for t
in test
.split(','):
2412 matches_code_based_tests
= [item
for item
in clsmembers
if item
[0] == t
]
2413 if len(matches_code_based_tests
) > 0:
2414 code_based_tests
.append(matches_code_based_tests
[0][1])
2416 logger
.critical("Test '{}' is not among the possible ones".format(t
))
2418 if not code_based_tests
:
2420 for cls
in clsmembers
:
2421 # We exclude 'test_VIM_tenant_operations' unless it is specifically requested by the user
2422 if cls
[0].startswith('test_VIM') and cls
[0] != 'test_VIM_tenant_operations':
2423 code_based_tests
.append(cls
[1])
2425 logger
.debug("tests to be executed: {}".format(code_based_tests
))
2427 # TextTestRunner stream is set to /dev/null in order to avoid the method to directly print the result of tests.
2428 # This is handled in the tests using logging.
2429 stream
= open('/dev/null', 'w')
2431 # Run code based tests
2432 basic_tests_suite
= unittest
.TestSuite()
2433 for test
in code_based_tests
:
2434 basic_tests_suite
.addTest(unittest
.makeSuite(test
))
2435 result
= unittest
.TextTestRunner(stream
=stream
, failfast
=failfast
).run(basic_tests_suite
)
2436 executed
+= result
.testsRun
2437 failed
+= len(result
.failures
) + len(result
.errors
)
2438 if failfast
and failed
:
2440 if len(result
.failures
) > 0:
2441 logger
.debug("failures : {}".format(result
.failures
))
2442 if len(result
.errors
) > 0:
2443 logger
.debug("errors : {}".format(result
.errors
))
2444 return executed
, failed
2447 def test_deploy(args
):
2449 sys
.path
.append(os
.path
.dirname(os
.path
.dirname(os
.path
.abspath(__file__
))) + "/osm_ro")
2450 import openmanoclient
2453 test_config
["test_directory"] = os
.path
.dirname(__file__
) + "/RO_tests"
2454 test_config
["image_name"] = args
.image_name
2455 test_config
["mgmt_net"] = args
.mgmt_net
2456 test_config
["manual"] = args
.manual
2457 test_directory_content
= os
.listdir(test_config
["test_directory"])
2458 # If only want to obtain a tests list print it and exit
2460 msg
= "the 'deploy' set tests are:\n\t" + ', '.join(sorted(test_directory_content
))
2465 descriptor_based_tests
= []
2466 # Create the list of tests to be run
2467 code_based_tests
= []
2469 for test
in args
.tests
:
2470 for t
in test
.split(','):
2471 if t
in test_directory_content
:
2472 descriptor_based_tests
.append(t
)
2474 logger
.critical("Test '{}' is not among the possible ones".format(t
))
2476 if not descriptor_based_tests
:
2478 descriptor_based_tests
= test_directory_content
2480 logger
.debug("tests to be executed: {}".format(code_based_tests
))
2482 # import openmanoclient from relative path
2483 test_config
["client"] = openmanoclient
.openmanoclient(
2484 endpoint_url
=args
.endpoint_url
,
2485 tenant_name
=args
.tenant_name
,
2486 datacenter_name
=args
.datacenter
,
2487 debug
=args
.debug
, logger
=test_config
["logger_name"])
2489 # TextTestRunner stream is set to /dev/null in order to avoid the method to directly print the result of tests.
2490 # This is handled in the tests using logging.
2491 stream
= open('/dev/null', 'w')
2492 # This scenario based tests are defined as directories inside the directory defined in 'test_directory'
2493 for test
in descriptor_based_tests
:
2494 test_config
["test_folder"] = test
2495 test_suite
= unittest
.TestSuite()
2496 test_suite
.addTest(unittest
.makeSuite(descriptor_based_scenario_test
))
2497 result
= unittest
.TextTestRunner(stream
=stream
, failfast
=False).run(test_suite
)
2498 executed
+= result
.testsRun
2499 failed
+= len(result
.failures
) + len(result
.errors
)
2500 if failfast
and failed
:
2502 if len(result
.failures
) > 0:
2503 logger
.debug("failures : {}".format(result
.failures
))
2504 if len(result
.errors
) > 0:
2505 logger
.debug("errors : {}".format(result
.errors
))
2507 return executed
, failed
2509 if __name__
=="__main__":
2511 parser
= ArgumentParser(description
='Test RO module')
2512 parser
.add_argument('-v','--version', action
='version', help="Show current version",
2513 version
='%(prog)s version ' + __version__
+ ' ' + version_date
)
2516 parent_parser
= ArgumentParser(add_help
=False)
2517 parent_parser
.add_argument('--failfast', help='Stop when a test fails rather than execute all tests',
2518 dest
='failfast', action
="store_true", default
=False)
2519 parent_parser
.add_argument('--failed', help='Set logs to show only failed tests. --debug disables this option',
2520 dest
='failed', action
="store_true", default
=False)
2521 default_logger_file
= os
.path
.dirname(__file__
)+'/'+os
.path
.splitext(os
.path
.basename(__file__
))[0]+'.log'
2522 parent_parser
.add_argument('--list-tests', help='List all available tests', dest
='list_tests', action
="store_true",
2524 parent_parser
.add_argument('--logger_file', dest
='logger_file', default
=default_logger_file
,
2525 help='Set the logger file. By default '+default_logger_file
)
2526 parent_parser
.add_argument("-t", '--tenant', dest
='tenant_name', default
="osm",
2527 help="Set the openmano tenant to use for the test. By default 'osm'")
2528 parent_parser
.add_argument('--debug', help='Set logs to debug level', dest
='debug', action
="store_true")
2529 parent_parser
.add_argument('--timeout', help='Specify the instantiation timeout in seconds. By default 300',
2530 dest
='timeout', type=int, default
=300)
2531 parent_parser
.add_argument('--test', '--tests', help='Specify the tests to run', dest
='tests', action
="append")
2533 subparsers
= parser
.add_subparsers(help='test sets')
2535 # Deployment test set
2536 # -------------------
2537 deploy_parser
= subparsers
.add_parser('deploy', parents
=[parent_parser
],
2538 help="test deployment using descriptors at RO_test folder ")
2539 deploy_parser
.set_defaults(func
=test_deploy
)
2541 # Mandatory arguments
2542 mandatory_arguments
= deploy_parser
.add_argument_group('mandatory arguments')
2543 mandatory_arguments
.add_argument('-d', '--datacenter', required
=True, help='Set the datacenter to test')
2544 mandatory_arguments
.add_argument("-i", '--image-name', required
=True, dest
="image_name",
2545 help='Image name available at datacenter used for the tests')
2546 mandatory_arguments
.add_argument("-n", '--mgmt-net-name', required
=True, dest
='mgmt_net',
2547 help='Set the vim management network to use for tests')
2549 # Optional arguments
2550 deploy_parser
.add_argument('-m', '--manual-check', dest
='manual', action
="store_true", default
=False,
2551 help='Pause execution once deployed to allow manual checking of the '
2552 'deployed instance scenario')
2553 deploy_parser
.add_argument('-u', '--url', dest
='endpoint_url', default
='http://localhost:9090/openmano',
2554 help="Set the openmano server url. By default 'http://localhost:9090/openmano'")
2557 # -------------------
2558 vimconn_parser
= subparsers
.add_parser('vimconn', parents
=[parent_parser
], help="test vimconnector plugin")
2559 vimconn_parser
.set_defaults(func
=test_vimconnector
)
2560 # Mandatory arguments
2561 mandatory_arguments
= vimconn_parser
.add_argument_group('mandatory arguments')
2562 mandatory_arguments
.add_argument('--vimtype', choices
=['vmware', 'aws', 'openstack', 'openvim','azure'], required
=True,
2563 help='Set the vimconnector type to test')
2564 mandatory_arguments
.add_argument('-c', '--config', dest
='config_param', required
=True,
2565 help='Set the vimconnector specific config parameters in dictionary format')
2566 mandatory_arguments
.add_argument('-u', '--url', dest
='endpoint_url',required
=True, help="Set the vim connector url or Host IP")
2567 # Optional arguments
2568 vimconn_parser
.add_argument('-i', '--image-path', dest
='image_path', help="Provide image path present at RO container")
2569 vimconn_parser
.add_argument('-n', '--image-name', dest
='image_name', help="Provide image name for test")
2570 # TODO add optional arguments for vimconn tests
2571 # vimconn_parser.add_argument("-i", '--image-name', dest='image_name', help='<HELP>'))
2572 vimconn_parser
.add_argument('-s', '--sriov-net-name', dest
='sriov_net_name', help="Provide SRIOV network name for test")
2574 # Datacenter test set
2575 # -------------------
2576 vimconn_parser
= subparsers
.add_parser('vim', parents
=[parent_parser
], help="test vim")
2577 vimconn_parser
.set_defaults(func
=test_vim
)
2579 # Mandatory arguments
2580 mandatory_arguments
= vimconn_parser
.add_argument_group('mandatory arguments')
2581 mandatory_arguments
.add_argument('-d', '--datacenter', required
=True, help='Set the datacenter to test')
2583 # Optional arguments
2584 vimconn_parser
.add_argument('-u', '--url', dest
='endpoint_url', default
='http://localhost:9090/openmano',
2585 help="Set the openmano server url. By default 'http://localhost:9090/openmano'")
2588 # -------------------
2589 vimconn_parser
= subparsers
.add_parser('wim', parents
=[parent_parser
], help="test wim")
2590 vimconn_parser
.set_defaults(func
=test_wim
)
2592 # Mandatory arguments
2593 mandatory_arguments
= vimconn_parser
.add_argument_group('mandatory arguments')
2594 mandatory_arguments
.add_argument('-d', '--datacenter', required
=True, help='Set the datacenter to test')
2596 # Optional arguments
2597 vimconn_parser
.add_argument('-u', '--url', dest
='endpoint_url', default
='http://localhost:9090/openmano',
2598 help="Set the openmano server url. By default 'http://localhost:9090/openmano'")
2600 argcomplete
.autocomplete(parser
)
2601 args
= parser
.parse_args()
2605 # default logger level is INFO. Options --debug and --failed override this, being --debug prioritary
2606 logger_level
= 'INFO'
2608 logger_level
= 'DEBUG'
2610 logger_level
= 'WARNING'
2611 logger_name
= os
.path
.basename(__file__
)
2612 test_config
["logger_name"] = logger_name
2613 logger
= logging
.getLogger(logger_name
)
2614 logger
.setLevel(logger_level
)
2615 failfast
= args
.failfast
2617 # Configure a logging handler to store in a logging file
2618 if args
.logger_file
:
2619 fileHandler
= logging
.FileHandler(args
.logger_file
)
2620 formatter_fileHandler
= logging
.Formatter('%(asctime)s %(name)s %(levelname)s: %(message)s')
2621 fileHandler
.setFormatter(formatter_fileHandler
)
2622 logger
.addHandler(fileHandler
)
2624 # Configure a handler to print to stdout
2625 consoleHandler
= logging
.StreamHandler(sys
.stdout
)
2626 formatter_consoleHandler
= logging
.Formatter('%(asctime)s %(name)s %(levelname)s: %(message)s')
2627 consoleHandler
.setFormatter(formatter_consoleHandler
)
2628 logger
.addHandler(consoleHandler
)
2630 logger
.debug('Program started with the following arguments: ' + str(args
))
2632 # set test config parameters
2633 test_config
["timeout"] = args
.timeout
2634 test_config
["test_number"] = 1
2636 executed
, failed
= args
.func(args
)
2639 logger
.warning("Total number of tests: {}; Total number of failures/errors: {}".format(executed
, failed
))
2640 sys
.exit(1 if failed
else 0)