X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=test%2Ftest_RO.py;h=876d661a366da8abf8b94027f63328342be81642;hb=ab24d8b8fee8efe8ed5e2d57ba5f132cc58f2120;hp=5b47182deadac1795580e2bc40672c02a94117da;hpb=c705303457249e947055d5445295ba110cf3afd9;p=osm%2FRO.git diff --git a/test/test_RO.py b/test/test_RO.py index 5b47182d..876d661a 100755 --- a/test/test_RO.py +++ b/test/test_RO.py @@ -20,33 +20,32 @@ # ## -''' +""" Module for testing openmano functionality. It uses openmanoclient.py for invoking openmano -''' -__author__ = "Pablo Montes, Alfonso Tierno" -__date__ = "$16-Feb-2017 17:08:16$" -__version__ = "0.0.4" -version_date = "Jun 2017" +""" import logging import os -from argparse import ArgumentParser import argcomplete import unittest import string import inspect import random -import traceback +# import traceback import glob import yaml import sys import time -from pyvcloud.vcloudair import VCA import uuid -import json +from argparse import ArgumentParser + +__author__ = "Pablo Montes, Alfonso Tierno" +__date__ = "$16-Feb-2017 17:08:16$" +__version__ = "0.1.0" +version_date = "Oct 2017" + +test_config = {} # used for global variables with the test configuration -global test_config # used for global variables with the test configuration -test_config = {} class test_base(unittest.TestCase): test_index = 1 @@ -150,7 +149,7 @@ class test_VIM_datacenter_operations(test_base): self.datacenter = test_config["client"].attach_datacenter(name=self.__class__.datacenter_name, vim_tenant_name='fake') logger.debug("{}".format(self.datacenter)) - assert ('vim_tenants' in self.datacenter.get('datacenter', {})) + assert ('uuid' in self.datacenter.get('datacenter', {})) def test_030_list_attached_datacenter(self): self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, @@ -279,6 +278,7 @@ class test_VIM_tenant_operations(test_base): logger.debug("{}".format(tenant)) assert ('deleted' in tenant.get('result', "")) + class test_vimconn_connect(test_base): def test_000_connect(self): @@ -290,8 +290,12 @@ class test_vimconn_connect(test_base): if test_config['vimtype'] == 'vmware': vca_object = test_config["vim_conn"].connect() logger.debug("{}".format(vca_object)) - self.assertIsInstance(vca_object, VCA) - + self.assertIsNotNone(vca_object) + elif test_config['vimtype'] == 'openstack': + test_config["vim_conn"]._reload_connection() + network_list = test_config["vim_conn"].get_network_list() + logger.debug("{}".format(network_list)) + self.assertIsNotNone(network_list) class test_vimconn_new_network(test_base): network_name = None @@ -373,11 +377,16 @@ class test_vimconn_new_network(test_base): version = item['ip-profile']['ip-version'] dhcp_count = item['ip-profile']['dhcp']['count'] dhcp_enabled = item['ip-profile']['dhcp']['enabled'] + dhcp_start_address = item['ip-profile']['dhcp']['start-address'] + subnet_address = item['ip-profile']['subnet-address'] + self.__class__.network_name = _get_random_string(20) ip_profile = {'dhcp_count': dhcp_count, 'dhcp_enabled': dhcp_enabled, - 'ip_version': version + 'dhcp_start_address': dhcp_start_address, + 'ip_version': version, + 'subnet_address': subnet_address } self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, @@ -481,7 +490,11 @@ class test_vimconn_new_network(test_base): # refresh net status net_dict = test_config["vim_conn"].refresh_nets_status([unknown_net_id]) - self.assertEqual(net_dict, {}) + if test_config['vimtype'] == 'openstack': + self.assertEqual(net_dict[unknown_net_id]['status'], 'DELETED') + else: + # TODO : Fix vmware connector to return status DELETED as per vimconn.py + self.assertEqual(net_dict, {}) class test_vimconn_get_network_list(test_base): network_name = None @@ -525,7 +538,10 @@ class test_vimconn_get_network_list(test_base): inspect.currentframe().f_code.co_name) self.__class__.test_index += 1 - network_name = test_config['vim_conn'].get_network_name_by_id(self.__class__.network_id) + if test_config['vimtype'] == 'openstack': + network_name = test_config['vim_conn'].get_network(self.__class__.network_id)['name'] + else: + network_name = test_config['vim_conn'].get_network_name_by_id(self.__class__.network_id) # find network from list by it's name new_network_list = test_config["vim_conn"].get_network_list({'name': network_name}) @@ -556,7 +572,10 @@ class test_vimconn_get_network_list(test_base): inspect.currentframe().f_code.co_name) self.__class__.test_index += 1 - network_name = test_config['vim_conn'].get_network_name_by_id(self.__class__.network_id) + if test_config['vimtype'] == 'openstack': + network_name = test_config['vim_conn'].get_network(self.__class__.network_id)['name'] + else: + network_name = test_config['vim_conn'].get_network_name_by_id(self.__class__.network_id) # find network from list by it's shared value new_network_list = test_config["vim_conn"].get_network_list({'shared':Shared, 'name':network_name}) @@ -573,7 +592,10 @@ class test_vimconn_get_network_list(test_base): self.__class__.test_index += 1 tenant_list = test_config["vim_conn"].get_tenant_list() - network_name = test_config['vim_conn'].get_network_name_by_id(self.__class__.network_id) + if test_config['vimtype'] == 'openstack': + network_name = test_config['vim_conn'].get_network(self.__class__.network_id)['name'] + else: + network_name = test_config['vim_conn'].get_network_name_by_id(self.__class__.network_id) for tenant_item in tenant_list: if test_config['tenant'] == tenant_item.get('name'): @@ -594,7 +616,10 @@ class test_vimconn_get_network_list(test_base): self.__class__.test_index += 1 status = 'ACTIVE' - network_name = test_config['vim_conn'].get_network_name_by_id(self.__class__.network_id) + if test_config['vimtype'] == 'openstack': + network_name = test_config['vim_conn'].get_network(self.__class__.network_id)['name'] + else: + network_name = test_config['vim_conn'].get_network_name_by_id(self.__class__.network_id) # find network from list by it's status new_network_list = test_config["vim_conn"].get_network_list({'status':status, @@ -653,9 +678,10 @@ class test_vimconn_get_network(test_base): self.__class__.test_index, inspect.currentframe().f_code.co_name) self.__class__.test_index += 1 + with self.assertRaises(Exception) as context: + test_config["vim_conn"].get_network(Non_exist_id) - network_info = test_config["vim_conn"].get_network(Non_exist_id) - self.assertEqual(network_info, {}) + self.assertEqual((context.exception).http_code, 404) class test_vimconn_delete_network(test_base): network_name = None @@ -695,7 +721,7 @@ class test_vimconn_delete_network(test_base): with self.assertRaises(Exception) as context: test_config["vim_conn"].delete_network(Non_exist_id) - self.assertEqual((context.exception).http_code, 400) + self.assertEqual((context.exception).http_code, 404) class test_vimconn_get_flavor(test_base): @@ -719,10 +745,12 @@ class test_vimconn_get_flavor(test_base): vcpus = item['vcpus'] disk = item['disk'] - flavor_data = {'ram': ram, + flavor_data = { + 'name' : _get_random_string(20), + 'ram': ram, 'vcpus': vcpus, 'disk': disk - } + } self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, @@ -760,7 +788,7 @@ class test_vimconn_new_flavor(test_base): flavor_id = None def test_000_new_flavor(self): - flavor_data = {'ram': 1024, 'vpcus': 1, 'disk': 10} + flavor_data = {'name': _get_random_string(20), 'ram': 1024, 'vpcus': 1, 'disk': 10} self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, @@ -769,8 +797,8 @@ class test_vimconn_new_flavor(test_base): # create new flavor self.__class__.flavor_id = test_config["vim_conn"].new_flavor(flavor_data) - self.assertEqual(type(self.__class__.flavor_id),str) - self.assertIsInstance(uuid.UUID(self.__class__.flavor_id),uuid.UUID) + self.assertIsInstance(self.__class__.flavor_id, (str, unicode)) + self.assertIsInstance(uuid.UUID(self.__class__.flavor_id), uuid.UUID) def test_010_delete_flavor(self): self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], @@ -822,10 +850,11 @@ class test_vimconn_new_image(test_base): image_path = test_config['image_path'] if image_path: - image_id = test_config["vim_conn"].new_image({ 'name': 'TestImage', 'location' : image_path }) + self.__class__.image_id = test_config["vim_conn"].new_image({ 'name': 'TestImage', 'location' : image_path, 'metadata': {'upload_location':None} }) time.sleep(20) - self.assertEqual(type(image_id),str) - self.assertIsInstance(uuid.UUID(image_id),uuid.UUID) + + self.assertIsInstance(self.__class__.image_id, (str, unicode)) + self.assertIsInstance(uuid.UUID(self.__class__.image_id), uuid.UUID) else: self.skipTest("Skipping test as image file not present at RO container") @@ -838,7 +867,7 @@ class test_vimconn_new_image(test_base): self.__class__.test_index += 1 with self.assertRaises(Exception) as context: - test_config["vim_conn"].new_image({ 'name': 'TestImage', 'location' : Non_exist_image_path }) + test_config["vim_conn"].new_image({ 'name': 'TestImage', 'location' : Non_exist_image_path}) self.assertEqual((context.exception).http_code, 400) @@ -849,7 +878,8 @@ class test_vimconn_new_image(test_base): self.__class__.test_index += 1 image_id = test_config["vim_conn"].delete_image(self.__class__.image_id) - self.assertEqual(type(image_id),str) + + self.assertIsInstance(image_id, (str, unicode)) def test_030_delete_image_negative(self): Non_exist_image_id = str(uuid.uuid4()) @@ -907,8 +937,8 @@ class test_vimconn_get_image_list(test_base): if 'name' in item: self.__class__.image_name = item['name'] self.__class__.image_id = item['id'] - self.assertEqual(type(self.__class__.image_name),str) - self.assertEqual(type(self.__class__.image_id),str) + self.assertIsInstance(self.__class__.image_name, (str, unicode)) + self.assertIsInstance(self.__class__.image_id, (str, unicode)) def test_010_get_image_list_by_name(self): self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], @@ -919,9 +949,9 @@ class test_vimconn_get_image_list(test_base): image_list = test_config["vim_conn"].get_image_list({'name': self.__class__.image_name}) for item in image_list: - self.assertEqual(type(item['id']), str) + self.assertIsInstance(item['id'], (str, unicode)) + self.assertIsInstance(item['name'], (str, unicode)) self.assertEqual(item['id'], self.__class__.image_id) - self.assertEqual(type(item['name']), str) self.assertEqual(item['name'], self.__class__.image_name) def test_020_get_image_list_by_id(self): @@ -933,10 +963,10 @@ class test_vimconn_get_image_list(test_base): filter_image_list = test_config["vim_conn"].get_image_list({'id': self.__class__.image_id}) for item1 in filter_image_list: - self.assertEqual(type(item1.get('id')), str) - self.assertEqual(item1.get('id'), self.__class__.image_id) - self.assertEqual(type(item1.get('name')), str) - self.assertEqual(item1.get('name'), self.__class__.image_name) + self.assertIsInstance(item1['id'], (str, unicode)) + self.assertIsInstance(item1['name'], (str, unicode)) + self.assertEqual(item1['id'], self.__class__.image_id) + self.assertEqual(item1['name'], self.__class__.image_name) def test_030_get_image_list_negative(self): Non_exist_image_id = uuid.uuid4() @@ -977,7 +1007,7 @@ class test_vimconn_new_vminstance(test_base): vpci = "0000:00:11.0" name = "eth0" - flavor_data = {'ram': 1024, 'vcpus': 1, 'disk': 10} + flavor_data = {'name': _get_random_string(20), 'ram': 1024, 'vcpus': 1, 'disk': 10} # create new flavor flavor_id = test_config["vim_conn"].new_flavor(flavor_data) @@ -1003,12 +1033,12 @@ class test_vimconn_new_vminstance(test_base): net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'vpci': vpci, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}] - self.__class__.instance_id = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=self.__class__.image_id, flavor_id=flavor_id, net_list=net_list) + self.__class__.instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False, image_id=self.__class__.image_id, flavor_id=flavor_id, net_list=net_list) - self.assertEqual(type(self.__class__.instance_id),str) + self.assertIsInstance(self.__class__.instance_id, (str, unicode)) def test_010_new_vminstance_by_model(self): - flavor_data = {'ram': 1024, 'vcpus': 2, 'disk': 10} + flavor_data = {'name': _get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10} model_name = 'e1000' name = 'eth0' @@ -1022,17 +1052,17 @@ class test_vimconn_new_vminstance(test_base): net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True, 'model': model_name, 'type': 'virtual', 'net_id': self.__class__.network_id}] - instance_id = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=self.__class__.image_id, - flavor_id=flavor_id, - net_list=net_list) - self.assertEqual(type(instance_id),str) + instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False, image_id=self.__class__.image_id,flavor_id=flavor_id,net_list=net_list) + + self.assertIsInstance(instance_id, (str, unicode)) + # Deleting created vm instance logger.info("Deleting created vm intance") test_config["vim_conn"].delete_vminstance(instance_id) time.sleep(10) def test_020_new_vminstance_by_net_use(self): - flavor_data = {'ram': 1024, 'vcpus': 2, 'disk': 10} + flavor_data = {'name': _get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10} net_use = 'data' name = 'eth0' @@ -1046,17 +1076,18 @@ class test_vimconn_new_vminstance(test_base): net_list = [{'use': net_use, 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}] - instance_id = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=self.__class__.image_id, + instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False, image_id=self.__class__.image_id,disk_list=None, flavor_id=flavor_id, net_list=net_list) - self.assertEqual(type(instance_id),str) + self.assertIsInstance(instance_id, (str, unicode)) + # Deleting created vm instance logger.info("Deleting created vm intance") test_config["vim_conn"].delete_vminstance(instance_id) time.sleep(10) def test_030_new_vminstance_by_net_type(self): - flavor_data = {'ram': 1024, 'vcpus': 2, 'disk': 10} + flavor_data = {'name':_get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10} _type = 'VF' name = 'eth0' @@ -1068,19 +1099,46 @@ class test_vimconn_new_vminstance(test_base): inspect.currentframe().f_code.co_name) self.__class__.test_index += 1 - net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True, 'type': _type, 'net_id': self.__class__.network_id}] + if test_config['vimtype'] == 'vmware': + net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True, + 'type': _type, 'net_id': self.__class__.network_id}] + + instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=self.__class__.image_id, + flavor_id=flavor_id, + net_list=net_list) + self.assertEqual(type(instance_id),str) + + if test_config['vimtype'] == 'openstack': + # create network of type data + network_name = _get_random_string(20) + net_type = 'data' + + network_id = test_config["vim_conn"].new_network(net_name=network_name, + net_type=net_type) + net_list = [{'use': net_type, 'name': name, 'floating_ip': False, 'port_security': True, + 'type': _type, 'net_id': network_id}] + + instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False, + image_id=self.__class__.image_id, disk_list=None, + flavor_id=flavor_id, + net_list=net_list) + + self.assertEqual(type(instance_id), unicode) + + # delete created network + result = test_config["vim_conn"].delete_network(network_id) + if result: + logger.info("Network id {} sucessfully deleted".format(network_id)) + else: + logger.info("Failed to delete network id {}".format(network_id)) - instance_id = test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=self.__class__.image_id, - flavor_id=flavor_id, - net_list=net_list) - self.assertEqual(type(instance_id),str) # Deleting created vm instance logger.info("Deleting created vm intance") test_config["vim_conn"].delete_vminstance(instance_id) time.sleep(10) def test_040_new_vminstance_by_cloud_config(self): - flavor_data = {'ram': 1024, 'vcpus': 2, 'disk': 10} + flavor_data = {'name': _get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10} name = 'eth0' user_name = 'test_user' @@ -1100,21 +1158,21 @@ class test_vimconn_new_vminstance(test_base): net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}] - instance_id = test_config["vim_conn"].new_vminstance(name='Cloud_vm', image_id=self.__class__.image_id, - flavor_id=flavor_id, - net_list=net_list, - cloud_config=cloud_data) - self.assertEqual(type(instance_id),str) + instance_id, _ = test_config["vim_conn"].new_vminstance(name='Cloud_vm', description='', start=False, + image_id=self.__class__.image_id, flavor_id=flavor_id,net_list=net_list,cloud_config=cloud_data) + + self.assertIsInstance(instance_id, (str, unicode)) + # Deleting created vm instance logger.info("Deleting created vm intance") test_config["vim_conn"].delete_vminstance(instance_id) time.sleep(10) def test_050_new_vminstance_by_disk_list(self): - flavor_data = {'ram': 1024, 'vcpus': 2, 'disk': 10} + flavor_data = {'name':_get_random_string(20),'ram': 1024, 'vcpus': 2, 'disk': 10} name = 'eth0' - device_data = [{'image_id': self.__class__.image_id, 'size': '5'}] + device_data = [{'image_id': self.__class__.image_id, 'size': '10'}] # create new flavor flavor_id = test_config["vim_conn"].new_flavor(flavor_data) @@ -1126,11 +1184,12 @@ class test_vimconn_new_vminstance(test_base): net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}] - instance_id = test_config["vim_conn"].new_vminstance(name='VM_test1', image_id=self.__class__.image_id, + instance_id, _ = test_config["vim_conn"].new_vminstance(name='VM_test1', description='', start=False, image_id=self.__class__.image_id, flavor_id=flavor_id, net_list=net_list, disk_list=device_data) - self.assertEqual(type(instance_id),str) + + self.assertIsInstance(instance_id, (str, unicode)) # Deleting created vm instance logger.info("Deleting created vm intance") test_config["vim_conn"].delete_vminstance(instance_id) @@ -1149,10 +1208,12 @@ class test_vimconn_new_vminstance(test_base): net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}] with self.assertRaises(Exception) as context: - test_config["vim_conn"].new_vminstance(name='Test1_vm', image_id=unknown_image_id, + test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False, image_id=unknown_image_id, flavor_id=unknown_flavor_id, net_list=net_list) - self.assertEqual((context.exception).http_code, 404) + + self.assertIn((context.exception).http_code, (400, 404)) + def test_070_get_vminstance(self): self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], @@ -1193,16 +1254,49 @@ class test_vimconn_new_vminstance(test_base): self.__class__.test_index, inspect.currentframe().f_code.co_name) self.__class__.test_index += 1 - vm_list = [] - vm_list.append(self.__class__.instance_id) - # refresh vm status - vm_info = test_config["vim_conn"].refresh_vms_status(vm_list) - for attr in vm_info[self.__class__.instance_id]: - if attr == 'status': - self.assertEqual(vm_info[self.__class__.instance_id][attr], 'ACTIVE') - if attr == 'interfaces': - self.assertEqual(type(vm_info[self.__class__.instance_id][attr]), list) + if test_config['vimtype'] == 'vmware': + vm_list = [] + vm_list.append(self.__class__.instance_id) + + # refresh vm status + vm_info = test_config["vim_conn"].refresh_vms_status(vm_list) + for attr in vm_info[self.__class__.instance_id]: + if attr == 'status': + self.assertEqual(vm_info[self.__class__.instance_id][attr], 'ACTIVE') + if attr == 'interfaces': + self.assertEqual(type(vm_info[self.__class__.instance_id][attr]), list) + + if test_config['vimtype'] == 'openstack': + vpci = "0000:00:11.0" + name = "eth0" + + flavor_data = {'name': _get_random_string(20), 'ram': 1024, 'vcpus': 1, 'disk': 10} + + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + # create new vm instance + net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'vpci': vpci, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}] + + instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False, image_id=self.__class__.image_id, flavor_id=flavor_id, net_list=net_list) + + time.sleep(30) + vm_list = [] + vm_list.append(instance_id) + + # refresh vm status + vm_info = test_config["vim_conn"].refresh_vms_status(vm_list) + for attr in vm_info[instance_id]: + if attr == 'status': + self.assertEqual(vm_info[instance_id][attr], 'ACTIVE') + if attr == 'interfaces': + self.assertEqual(type(vm_info[instance_id][attr]), list) + + #Deleting created vm instance + logger.info("Deleting created vm intance") + test_config["vim_conn"].delete_vminstance(instance_id) + time.sleep(10) + def test_100_refresh_vms_status_negative(self): unknown_id = str(uuid.uuid4()) @@ -1213,7 +1307,12 @@ class test_vimconn_new_vminstance(test_base): self.__class__.test_index += 1 vm_dict = test_config["vim_conn"].refresh_vms_status([unknown_id]) - self.assertEqual(vm_dict, {}) + + if test_config['vimtype'] == 'vmware': + self.assertEqual(vm_dict,{}) + + if test_config['vimtype'] == 'openstack': + self.assertEqual(vm_dict[unknown_id]['status'], 'DELETED') def test_110_action_vminstance(self): self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], @@ -1221,12 +1320,43 @@ class test_vimconn_new_vminstance(test_base): inspect.currentframe().f_code.co_name) self.__class__.test_index += 1 - action_list = ['shutdown','start','shutoff','rebuild','pause','resume'] - # various action on vminstace - for action in action_list: - instance_id = test_config["vim_conn"].action_vminstance(self.__class__.instance_id, - { action: None}) - self.assertEqual(instance_id, self.__class__.instance_id) + if test_config['vimtype'] == 'vmware': + action_list = ['shutdown', 'start', 'shutoff', 'rebuild', 'pause', 'resume'] + # various action on vminstace + for action in action_list: + instance_id = test_config["vim_conn"].action_vminstance(self.__class__.instance_id, + {action: None}) + self.assertEqual(instance_id, self.__class__.instance_id) + + if test_config['vimtype'] == 'openstack': + # create new vm instance + vpci = "0000:00:11.0" + name = "eth0" + + flavor_data = {'name': _get_random_string(20), 'ram': 1024, 'vcpus': 1, 'disk': 10} + + # create new flavor + flavor_id = test_config["vim_conn"].new_flavor(flavor_data) + + net_list = [{'use': self.__class__.net_type, 'name': name, 'floating_ip': False, 'vpci': vpci, 'port_security': True, 'type': 'virtual', 'net_id': self.__class__.network_id}] + + new_instance_id, _ = test_config["vim_conn"].new_vminstance(name='Test1_vm', description='', start=False, image_id=self.__class__.image_id, flavor_id=flavor_id, net_list=net_list) + + action_list = ['shutdown','start','shutoff','rebuild','start','pause','start'] + + # various action on vminstace + for action in action_list: + # sleep for sometime till status is changed + time.sleep(25) + instance_id = test_config["vim_conn"].action_vminstance(new_instance_id, + { action: None}) + + self.assertTrue(instance_id is None) + + # Deleting created vm instance + logger.info("Deleting created vm intance") + test_config["vim_conn"].delete_vminstance(new_instance_id) + time.sleep(10) def test_120_action_vminstance_negative(self): non_exist_id = str(uuid.uuid4()) @@ -1239,7 +1369,8 @@ class test_vimconn_new_vminstance(test_base): with self.assertRaises(Exception) as context: test_config["vim_conn"].action_vminstance(non_exist_id, { action: None}) - self.assertEqual((context.exception).http_code, 400) + self.assertEqual((context.exception).http_code, 404) + def test_130_delete_vminstance(self): self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], @@ -1267,8 +1398,8 @@ class test_vimconn_get_tenant_list(test_base): for item in tenant_list: if test_config['tenant'] == item['name']: self.__class__.tenant_id = item['id'] - self.assertEqual(type(item['name']), str) - self.assertEqual(type(item['id']), str) + self.assertIsInstance(item['name'], (str, unicode)) + self.assertIsInstance(item['id'], (str, unicode)) def test_010_get_tenant_list_by_id(self): self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], @@ -1280,7 +1411,7 @@ class test_vimconn_get_tenant_list(test_base): filter_tenant_list = test_config["vim_conn"].get_tenant_list({'id': self.__class__.tenant_id}) for item in filter_tenant_list: - self.assertEqual(type(item['id']), str) + self.assertIsInstance(item['id'], (str, unicode)) self.assertEqual(item['id'], self.__class__.tenant_id) def test_020_get_tenant_list_by_name(self): @@ -1293,7 +1424,7 @@ class test_vimconn_get_tenant_list(test_base): filter_tenant_list = test_config["vim_conn"].get_tenant_list({'name': test_config['tenant']}) for item in filter_tenant_list: - self.assertEqual(type(item['name']), str) + self.assertIsInstance(item['name'], (str, unicode)) self.assertEqual(item['name'], test_config['tenant']) def test_030_get_tenant_list_by_name_and_id(self): @@ -1307,8 +1438,8 @@ class test_vimconn_get_tenant_list(test_base): 'id': self.__class__.tenant_id}) for item in filter_tenant_list: - self.assertEqual(type(item['name']), str) - self.assertEqual(type(item['id']), str) + self.assertIsInstance(item['name'], (str, unicode)) + self.assertIsInstance(item['id'], (str, unicode)) self.assertEqual(item['name'], test_config['tenant']) self.assertEqual(item['id'], self.__class__.tenant_id) @@ -1325,6 +1456,7 @@ class test_vimconn_get_tenant_list(test_base): self.assertEqual(filter_tenant_list, []) + class test_vimconn_new_tenant(test_base): tenant_id = None @@ -1335,10 +1467,11 @@ class test_vimconn_new_tenant(test_base): inspect.currentframe().f_code.co_name) self.__class__.test_index += 1 - self.__class__.tenant_id = test_config["vim_conn"].new_tenant(tenant_name) + self.__class__.tenant_id = test_config["vim_conn"].new_tenant(tenant_name, "") time.sleep(15) - self.assertEqual(type(self.__class__.tenant_id), str) + self.assertIsInstance(self.__class__.tenant_id, (str, unicode)) + def test_010_new_tenant_negative(self): Invalid_tenant_name = 10121 @@ -1348,10 +1481,11 @@ class test_vimconn_new_tenant(test_base): self.__class__.test_index += 1 with self.assertRaises(Exception) as context: - test_config["vim_conn"].new_tenant(Invalid_tenant_name) + test_config["vim_conn"].new_tenant(Invalid_tenant_name, "") self.assertEqual((context.exception).http_code, 400) + def test_020_delete_tenant(self): self.__class__.test_text = "{}.{}. TEST {}".format(test_config["test_number"], self.__class__.test_index, @@ -1359,7 +1493,8 @@ class test_vimconn_new_tenant(test_base): self.__class__.test_index += 1 tenant_id = test_config["vim_conn"].delete_tenant(self.__class__.tenant_id) - self.assertEqual(type(tenant_id), str) + + self.assertIsInstance(tenant_id, (str, unicode)) def test_030_delete_tenant_negative(self): Non_exist_tenant_name = 'Test_30_tenant' @@ -1373,6 +1508,7 @@ class test_vimconn_new_tenant(test_base): self.assertEqual((context.exception).http_code, 404) + ''' IMPORTANT NOTE The following unittest class does not have the 'test_' on purpose. This test is the one used for the @@ -1381,14 +1517,13 @@ scenario based tests. class descriptor_based_scenario_test(test_base): test_index = 0 scenario_test_path = None - scenario_uuid = None - instance_scenario_uuid = None - to_delete_list = [] @classmethod def setUpClass(cls): cls.test_index = 1 cls.to_delete_list = [] + cls.scenario_uuids = [] + cls.instance_scenario_uuids = [] cls.scenario_test_path = test_config["test_directory"] + '/' + test_config["test_folder"] logger.info("{}. {} {}".format(test_config["test_number"], cls.__name__, test_config["test_folder"])) @@ -1401,55 +1536,72 @@ class descriptor_based_scenario_test(test_base): inspect.currentframe().f_code.co_name, test_config["test_folder"]) self.__class__.test_index += 1 - vnfd_files = glob.glob(self.__class__.scenario_test_path+'/vnfd_*.yaml') + # load VNFD and NSD + descriptor_files = glob.glob(self.__class__.scenario_test_path+'/*.yaml') + vnf_descriptors = [] + scenario_descriptors = [] + for descriptor_file in descriptor_files: + with open(descriptor_file, 'r') as stream: + descriptor = yaml.load(stream) + if "vnf" in descriptor or "vnfd:vnfd-catalog" in descriptor or "vnfd-catalog" in descriptor: + vnf_descriptors.append(descriptor) + else: + scenario_descriptors.append(descriptor) + scenario_file = glob.glob(self.__class__.scenario_test_path + '/scenario_*.yaml') - if len(vnfd_files) == 0 or len(scenario_file) > 1: + if not vnf_descriptors or not scenario_descriptors or len(scenario_descriptors) > 1: raise Exception("Test '{}' not valid. It must contain an scenario file and at least one vnfd file'".format( test_config["test_folder"])) - #load all vnfd - for vnfd in vnfd_files: - with open(vnfd, 'r') as stream: - vnf_descriptor = yaml.load(stream) - - vnfc_list = vnf_descriptor['vnf']['VNFC'] - for vnfc in vnfc_list: - vnfc['image name'] = test_config["image_name"] - devices = vnfc.get('devices',[]) - for device in devices: - if device['type'] == 'disk' and 'image name' in device: - device['image name'] = test_config["image_name"] - + # load all vnfd + for vnf_descriptor in vnf_descriptors: logger.debug("VNF descriptor: {}".format(vnf_descriptor)) - vnf = test_config["client"].create_vnf(descriptor=vnf_descriptor) + vnf = test_config["client"].create_vnf(descriptor=vnf_descriptor, image_name=test_config["image_name"]) logger.debug(vnf) + if 'vnf' in vnf: + vnf_uuid = vnf['vnf']['uuid'] + else: + vnf_uuid = vnf['vnfd'][0]['uuid'] self.__class__.to_delete_list.insert(0, {"item": "vnf", "function": test_config["client"].delete_vnf, - "params": {"uuid": vnf['vnf']['uuid']}}) - - #load the scenario definition - with open(scenario_file[0], 'r') as stream: - scenario_descriptor = yaml.load(stream) - networks = scenario_descriptor['scenario']['networks'] - networks[test_config["mgmt_net"]] = networks.pop('mgmt') - logger.debug("Scenario descriptor: {}".format(scenario_descriptor)) - scenario = test_config["client"].create_scenario(descriptor=scenario_descriptor) - logger.debug(scenario) - self.__class__.to_delete_list.insert(0,{"item": "scenario", "function": test_config["client"].delete_scenario, - "params":{"uuid": scenario['scenario']['uuid']} }) - self.__class__.scenario_uuid = scenario['scenario']['uuid'] + "params": {"uuid": vnf_uuid}}) + + # load the scenario definition + for scenario_descriptor in scenario_descriptors: + # networks = scenario_descriptor['scenario']['networks'] + # networks[test_config["mgmt_net"]] = networks.pop('mgmt') + logger.debug("Scenario descriptor: {}".format(scenario_descriptor)) + scenario = test_config["client"].create_scenario(descriptor=scenario_descriptor) + logger.debug(scenario) + if 'scenario' in scenario: + scenario_uuid = scenario['scenario']['uuid'] + else: + scenario_uuid = scenario['nsd'][0]['uuid'] + self.__class__.to_delete_list.insert(0, {"item": "scenario", + "function": test_config["client"].delete_scenario, + "params": {"uuid": scenario_uuid}}) + self.__class__.scenario_uuids.append(scenario_uuid) def test_010_instantiate_scenario(self): self.__class__.test_text = "{}.{}. TEST {} {}".format(test_config["test_number"], self.__class__.test_index, inspect.currentframe().f_code.co_name, test_config["test_folder"]) self.__class__.test_index += 1 - - instance = test_config["client"].create_instance(scenario_id=self.__class__.scenario_uuid, - name=self.__class__.test_text) - self.__class__.instance_scenario_uuid = instance['uuid'] - logger.debug(instance) - self.__class__.to_delete_list.insert(0, {"item": "instance", "function": test_config["client"].delete_instance, - "params": {"uuid": instance['uuid']}}) + for scenario_uuid in self.__class__.scenario_uuids: + instance_descriptor = { + "instance":{ + "name": self.__class__.test_text, + "scenario": scenario_uuid, + "networks":{ + "mgmt": {"sites": [ { "netmap-use": test_config["mgmt_net"]} ]} + } + } + } + instance = test_config["client"].create_instance(instance_descriptor) + self.__class__.instance_scenario_uuids.append(instance['uuid']) + logger.debug(instance) + self.__class__.to_delete_list.insert(0, {"item": "instance", + "function": test_config["client"].delete_instance, + "params": {"uuid": instance['uuid']}}) def test_020_check_deployent(self): self.__class__.test_text = "{}.{}. TEST {} {}".format(test_config["test_number"], self.__class__.test_index, @@ -1462,15 +1614,19 @@ class descriptor_based_scenario_test(test_base): return keep_waiting = test_config["timeout"] - instance_active = False - while True: - result = check_instance_scenario_active(self.__class__.instance_scenario_uuid) - if result[0]: - break - elif 'ERROR' in result[1]: - msg = 'Got error while waiting for the instance to get active: '+result[1] - logging.error(msg) - raise Exception(msg) + pending_instance_scenario_uuids = list(self.__class__.instance_scenario_uuids) # make a copy + while pending_instance_scenario_uuids: + index = 0 + while index < len(pending_instance_scenario_uuids): + result = check_instance_scenario_active(pending_instance_scenario_uuids[index]) + if result[0]: + del pending_instance_scenario_uuids[index] + break + elif 'ERROR' in result[1]: + msg = 'Got error while waiting for the instance to get active: '+result[1] + logging.error(msg) + raise Exception(msg) + index += 1 if keep_waiting >= 5: time.sleep(5) @@ -1520,7 +1676,7 @@ def test_vimconnector(args): tenant_name = args.tenant_name test_config['tenant'] = tenant_name - config_params = json.loads(args.config_param) + config_params = yaml.load(args.config_param) org_name = config_params.get('orgname') org_user = config_params.get('user') org_passwd = config_params.get('passwd') @@ -1535,6 +1691,29 @@ def test_vimconnector(args): import vimconn_aws as vim elif args.vimtype == "openstack": import vimconn_openstack as vim + + test_config["test_directory"] = os.path.dirname(__file__) + "/RO_tests" + + tenant_name = args.tenant_name + test_config['tenant'] = tenant_name + config_params = yaml.load(args.config_param) + os_user = config_params.get('user') + os_passwd = config_params.get('passwd') + vim_url = args.endpoint_url + test_config['image_path'] = args.image_path + test_config['image_name'] = args.image_name + + # openstack connector obj + vim_persistent_info = {} + test_config['vim_conn'] = vim.vimconnector( + uuid="test-uuid-1", name="VIO-openstack", + tenant_id=None, tenant_name=tenant_name, + url=vim_url, url_admin=None, + user=os_user, passwd=os_passwd, + config=config_params, persistent_info=vim_persistent_info + ) + test_config['vim_conn'].debug = "true" + elif args.vimtype == "openvim": import vimconn_openvim as vim else: @@ -1547,7 +1726,7 @@ def test_vimconnector(args): if args.list_tests: tests_names = [] for cls in clsmembers: - if cls[0].startswith('test_vimconnector'): + if cls[0].startswith('test_vimconn'): tests_names.append(cls[0]) msg = "The 'vim' set tests are:\n\t" + ', '.join(sorted(tests_names)) @@ -1570,7 +1749,7 @@ def test_vimconnector(args): # include all tests for cls in clsmembers: # We exclude 'test_VIM_tenant_operations' unless it is specifically requested by the user - if cls[0].startswith('test_vimconnector'): + if cls[0].startswith('test_vimconn'): code_based_tests.append(cls[1]) logger.debug("tests to be executed: {}".format(code_based_tests))