def __init__(self, **kwargs):
super(VnfOnBoarding, self).__init__(**kwargs)
- self.tenant_created = False
- self.user_created = False
+ self.exist_obj = {'tenant': False, 'user': False}
self.tenant_name = CONST.__getattribute__(
'vnf_{}_tenant_name'.format(self.case_name))
- self.tenant_description = CONST.__getattribute__(
- 'vnf_{}_tenant_description'.format(self.case_name))
+ self.creds = {}
def run(self, **kwargs):
"""
return base.TestCase.EX_OK
else:
self.result = 0
+ self.stop_time = time.time()
return base.TestCase.EX_TESTCASE_FAILED
except Exception: # pylint: disable=broad-except
+ self.stop_time = time.time()
self.__logger.exception("Exception on VNF testing")
return base.TestCase.EX_TESTCASE_FAILED
Raise VnfPreparationException in case of problem
"""
try:
+ tenant_description = CONST.__getattribute__(
+ 'vnf_{}_tenant_description'.format(self.case_name))
self.__logger.info("Prepare VNF: %s, description: %s",
- self.tenant_name, self.tenant_description)
- admin_creds = os_utils.get_credentials()
+ self.tenant_name, tenant_description)
keystone_client = os_utils.get_keystone_client()
- self.tenant_created = os_utils.get_or_create_tenant_for_vnf(
- keystone_client, self.tenant_name, self.tenant_description)
- self.user_created = os_utils.get_or_create_user_for_vnf(
+ self.exist_obj['tenant'] = (
+ not os_utils.get_or_create_tenant_for_vnf(
+ keystone_client,
+ self.tenant_name,
+ tenant_description))
+ self.exist_obj['user'] = not os_utils.get_or_create_user_for_vnf(
keystone_client, self.tenant_name)
- creds = admin_creds.copy()
- creds.update({
+ self.creds = {
"tenant": self.tenant_name,
"username": self.tenant_name,
- "password": self.tenant_name
- })
+ "password": self.tenant_name,
+ "auth_url": os_utils.get_credentials()['auth_url']
+ }
return base.TestCase.EX_OK
except Exception: # pylint: disable=broad-except
self.__logger.exception("Exception raised during VNF preparation")
"""
self.__logger.info("test cleaning")
keystone_client = os_utils.get_keystone_client()
- if self.tenant_created:
+ if not self.exist_obj['tenant']:
os_utils.delete_tenant(keystone_client, self.tenant_name)
- if self.user_created:
+ if not self.exist_obj['user']:
os_utils.delete_user(keystone_client, self.tenant_name)
+++ /dev/null
-#!/usr/bin/env python
-# coding: utf8
-#######################################################################
-#
-# Copyright (c) 2015 Orange
-# valentin.boucher@orange.com
-#
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Apache License, Version 2.0
-# which accompanies this distribution, and is available at
-# http://www.apache.org/licenses/LICENSE-2.0
-########################################################################
-
-
-class Clearwater(object):
-
- def __init__(self, inputs={}, orchestrator=None, logger=None):
- self.config = inputs
- self.orchestrator = orchestrator
- self.logger = logger
- self.deploy = False
-
- def set_orchestrator(self, orchestrator):
- self.orchestrator = orchestrator
-
- def set_flavor_id(self, flavor_id):
- self.config['flavor_id'] = flavor_id
-
- def set_image_id(self, image_id):
- self.config['image_id'] = image_id
-
- def set_agent_user(self, agent_user):
- self.config['agent_user'] = agent_user
-
- def set_external_network_name(self, external_network_name):
- self.config['external_network_name'] = external_network_name
-
- def set_public_domain(self, public_domain):
- self.config['public_domain'] = public_domain
-
- def deploy_vnf(self, blueprint, bp_name='clearwater',
- dep_name='clearwater-opnfv'):
- if self.orchestrator:
- self.dep_name = dep_name
- error = self.orchestrator.download_upload_and_deploy_blueprint(
- blueprint, self.config, bp_name, dep_name)
- if error:
- return error
-
- self.deploy = True
-
- else:
- if self.logger:
- self.logger.error("Cloudify manager is down or not provide...")
-
- def undeploy_vnf(self):
- if self.orchestrator:
- if self.deploy:
- self.deploy = False
- self.orchestrator.undeploy_deployment(self.dep_name)
- else:
- if self.logger:
- self.logger.error("Clearwater isn't already deploy...")
- else:
- if self.logger:
- self.logger.error("Cloudify manager is down or not provide...")
import os
import pkg_resources
import shutil
+import time
import requests
ellis_ip,
params['email'])
self.logger.info('Create 1st calling number on Ellis')
- number_res = self.create_ellis_number(number_url, cookies)
+ i = 24
+ while rq.status_code != 200 and i > 0:
+ try:
+ number_res = self.create_ellis_number(number_url, cookies)
+ break
+ except:
+ if i == 1:
+ raise Exception("Unable to create a number")
+ self.logger.warn("Unable to create a number. Retry ..")
+ time.sleep(25)
+ i = i - 1
output_dict['number'] = number_res
if two_numbers:
import logging
import os
-import sys
-
-import requests
+import time
import yaml
+from scp import SCPClient
+
+from cloudify_rest_client import CloudifyClient
+from cloudify_rest_client.executions import Execution
-from functest.opnfv_tests.vnf.ims.clearwater import Clearwater
import functest.opnfv_tests.vnf.ims.clearwater_ims_base as clearwater_ims_base
-from functest.opnfv_tests.vnf.ims.orchestrator_cloudify import Orchestrator
from functest.utils.constants import CONST
-import functest.utils.functest_utils as ft_utils
import functest.utils.openstack_utils as os_utils
+from snaps.openstack.os_credentials import OSCreds
+from snaps.openstack.create_network import NetworkSettings, SubnetSettings, \
+ OpenStackNetwork
+from snaps.openstack.create_security_group import SecurityGroupSettings, \
+ SecurityGroupRuleSettings,\
+ Direction, Protocol, \
+ OpenStackSecurityGroup
+from snaps.openstack.create_router import RouterSettings, OpenStackRouter
+from snaps.openstack.create_instance import VmInstanceSettings, \
+ FloatingIpSettings, \
+ OpenStackVmInstance
+from snaps.openstack.create_flavor import FlavorSettings, OpenStackFlavor
+from snaps.openstack.create_image import ImageSettings, OpenStackImage
+from snaps.openstack.create_keypairs import KeypairSettings, OpenStackKeypair
+from snaps.openstack.create_network import PortSettings
+
+from functest.opnfv_tests.openstack.snaps import snaps_utils
+
+
__author__ = "Valentin Boucher <valentin.boucher@orange.com>"
class CloudifyIms(clearwater_ims_base.ClearwaterOnBoardingBase):
"""Clearwater vIMS deployed with Cloudify Orchestrator Case"""
+ __logger = logging.getLogger(__name__)
+
def __init__(self, **kwargs):
if "case_name" not in kwargs:
kwargs["case_name"] = "cloudify_ims"
super(CloudifyIms, self).__init__(**kwargs)
- self.logger = logging.getLogger(__name__)
- self.neutron_client = ''
- self.glance_client = ''
- self.keystone_client = ''
- self.nova_client = ''
# Retrieve the configuration
try:
except Exception:
raise Exception("VNF config file not found")
+ self.snaps_creds = ''
+ self.created_object = []
+
config_file = os.path.join(self.case_dir, self.config)
self.orchestrator = dict(
- requirements=get_config("cloudify.requirements", config_file),
- blueprint=get_config("cloudify.blueprint", config_file),
- inputs=get_config("cloudify.inputs", config_file)
+ requirements=get_config("orchestrator.requirements", config_file),
)
- self.logger.debug("Orchestrator configuration: %s", self.orchestrator)
+ self.details['orchestrator'] = dict(
+ name=get_config("orchestrator.name", config_file),
+ version=get_config("orchestrator.version", config_file),
+ status='ERROR',
+ result=''
+ )
+ self.__logger.debug("Orchestrator configuration %s", self.orchestrator)
self.vnf = dict(
- blueprint=get_config("clearwater.blueprint", config_file),
- deployment_name=get_config("clearwater.deployment_name",
- config_file),
- inputs=get_config("clearwater.inputs", config_file),
- requirements=get_config("clearwater.requirements", config_file)
+ descriptor=get_config("vnf.descriptor", config_file),
+ inputs=get_config("vnf.inputs", config_file),
+ requirements=get_config("vnf.requirements", config_file)
+ )
+ self.details['vnf'] = dict(
+ descriptor_version=self.vnf['descriptor']['version'],
+ name=get_config("vnf.name", config_file),
+ version=get_config("vnf.version", config_file),
)
- self.logger.debug("VNF configuration: %s", self.vnf)
+ self.__logger.debug("VNF configuration: %s", self.vnf)
+ self.details['test_vnf'] = dict(
+ name=get_config("vnf_test_suite.name", config_file),
+ version=get_config("vnf_test_suite.version", config_file)
+ )
self.images = get_config("tenant_images", config_file)
- self.logger.info("Images needed for vIMS: %s", self.images)
+ self.__logger.info("Images needed for vIMS: %s", self.images)
- def deploy_orchestrator(self):
+ def prepare(self):
+ super(CloudifyIms, self).prepare()
+
+ self.__logger.info("Additional pre-configuration steps")
- self.logger.info("Additional pre-configuration steps")
- self.neutron_client = os_utils.get_neutron_client(self.admin_creds)
- self.glance_client = os_utils.get_glance_client(self.admin_creds)
- self.keystone_client = os_utils.get_keystone_client(self.admin_creds)
- self.nova_client = os_utils.get_nova_client(self.admin_creds)
+ self.snaps_creds = OSCreds(
+ username=self.creds['username'],
+ password=self.creds['password'],
+ auth_url=self.creds['auth_url'],
+ project_name=self.creds['tenant'],
+ identity_api_version=int(os_utils.get_keystone_client_version()))
# needs some images
- self.logger.info("Upload some OS images if it doesn't exist")
- temp_dir = os.path.join(self.data_dir, "tmp/")
+ self.__logger.info("Upload some OS images if it doesn't exist")
for image_name, image_url in self.images.iteritems():
- self.logger.info("image: %s, url: %s", image_name, image_url)
- try:
- image_id = os_utils.get_image_id(self.glance_client,
- image_name)
- self.logger.debug("image_id: %s", image_id)
- except Exception:
- self.logger.error("Unexpected error: %s", sys.exc_info()[0])
-
- if image_id == '':
- self.logger.info("""%s image does not exist on glance repo.
- Try downloading this image
- and upload on glance !""",
- image_name)
- image_id = os_utils.download_and_add_image_on_glance(
- self.glance_client,
- image_name,
- image_url,
- temp_dir)
- # Need to extend quota
- self.logger.info("Update security group quota for this tenant")
- tenant_id = os_utils.get_tenant_id(self.keystone_client,
- self.tenant_name)
- self.logger.debug("Tenant id found %s", tenant_id)
- if not os_utils.update_sg_quota(self.neutron_client,
- tenant_id, 50, 100):
- self.logger.error("Failed to update security group quota"
- " for tenant " + self.tenant_name)
-
- self.logger.debug("group quota extended")
-
- # start the deployment of cloudify
+ self.__logger.info("image: %s, url: %s", image_name, image_url)
+ if image_url and image_name:
+ image_creator = OpenStackImage(
+ self.snaps_creds,
+ ImageSettings(name=image_name,
+ image_user='cloud',
+ img_format='qcow2',
+ url=image_url))
+ image_creator.create()
+ # self.created_object.append(image_creator)
+
+ def deploy_orchestrator(self):
+ """
+ Deploy Cloudify Manager
+
+ network, security group, fip, VM creation
+ """
+ # network creation
+
+ start_time = time.time()
+ self.__logger.info("Creating keypair ...")
+ kp_file = os.path.join(self.data_dir, "cloudify_ims.pem")
+ keypair_settings = KeypairSettings(name='cloudify_ims_kp',
+ private_filepath=kp_file)
+ keypair_creator = OpenStackKeypair(self.snaps_creds, keypair_settings)
+ keypair_creator.create()
+ self.created_object.append(keypair_creator)
+
+ self.__logger.info("Creating full network ...")
+ subnet_settings = SubnetSettings(name='cloudify_ims_subnet',
+ cidr='10.67.79.0/24')
+ network_settings = NetworkSettings(name='cloudify_ims_network',
+ subnet_settings=[subnet_settings])
+ network_creator = OpenStackNetwork(self.snaps_creds, network_settings)
+ network_creator.create()
+ self.created_object.append(network_creator)
+ ext_net_name = snaps_utils.get_ext_net_name(self.snaps_creds)
+ router_creator = OpenStackRouter(
+ self.snaps_creds,
+ RouterSettings(
+ name='cloudify_ims_router',
+ external_gateway=ext_net_name,
+ internal_subnets=[subnet_settings.name]))
+ router_creator.create()
+ self.created_object.append(router_creator)
+
+ # security group creation
+ self.__logger.info("Creating security group for cloudify manager vm")
+ sg_rules = list()
+ sg_rules.append(
+ SecurityGroupRuleSettings(sec_grp_name="sg-cloudify-manager",
+ direction=Direction.ingress,
+ protocol=Protocol.tcp, port_range_min=1,
+ port_range_max=65535))
+ sg_rules.append(
+ SecurityGroupRuleSettings(sec_grp_name="sg-cloudify-manager",
+ direction=Direction.ingress,
+ protocol=Protocol.udp, port_range_min=1,
+ port_range_max=65535))
+
+ securit_group_creator = OpenStackSecurityGroup(
+ self.snaps_creds,
+ SecurityGroupSettings(
+ name="sg-cloudify-manager",
+ rule_settings=sg_rules))
+
+ securit_group_creator.create()
+ self.created_object.append(securit_group_creator)
+
+ # orchestrator VM flavor
+ self.__logger.info("Get or create flavor for cloudify manager vm ...")
+
+ flavor_settings = FlavorSettings(
+ name=self.orchestrator['requirements']['flavor']['name'],
+ ram=self.orchestrator['requirements']['flavor']['ram_min'],
+ disk=50,
+ vcpus=2)
+ flavor_creator = OpenStackFlavor(self.snaps_creds, flavor_settings)
+ flavor_creator.create()
+ self.created_object.append(flavor_creator)
+ image_settings = ImageSettings(
+ name=self.orchestrator['requirements']['os_image'],
+ image_user='centos',
+ exists=True)
+
+ port_settings = PortSettings(name='cloudify_manager_port',
+ network_name=network_settings.name)
+
+ manager_settings = VmInstanceSettings(
+ name='cloudify_manager',
+ flavor=flavor_settings.name,
+ port_settings=[port_settings],
+ security_group_names=[securit_group_creator.sec_grp_settings.name],
+ floating_ip_settings=[FloatingIpSettings(
+ name='cloudify_manager_fip',
+ port_name=port_settings.name,
+ router_name=router_creator.router_settings.name)])
+
+ manager_creator = OpenStackVmInstance(self.snaps_creds,
+ manager_settings,
+ image_settings,
+ keypair_settings)
+
+ self.__logger.info("Creating cloudify manager VM")
+ manager_creator.create()
+ self.created_object.append(manager_creator)
+
public_auth_url = os_utils.get_endpoint('identity')
- self.logger.debug("CFY inputs: %s", self.orchestrator['inputs'])
- cfy = Orchestrator(self.data_dir, self.orchestrator['inputs'])
- self.orchestrator['object'] = cfy
- self.logger.debug("Orchestrator object created")
+ self.__logger.info("Set creds for cloudify manager")
+ cfy_creds = dict(keystone_username=self.tenant_name,
+ keystone_password=self.tenant_name,
+ keystone_tenant_name=self.tenant_name,
+ keystone_url=public_auth_url)
- self.logger.debug("Tenant name: %s", self.tenant_name)
+ cfy_client = CloudifyClient(host=manager_creator.get_floating_ip().ip,
+ username='admin',
+ password='admin',
+ tenant='default_tenant')
- cfy.set_credentials(username=self.tenant_name,
- password=self.tenant_name,
- tenant_name=self.tenant_name,
- auth_url=public_auth_url)
- self.logger.info("Credentials set in CFY")
+ self.orchestrator['object'] = cfy_client
- # orchestrator VM flavor
- self.logger.info("Check Flavor is available, if not create one")
- self.logger.debug("Flavor details %s ",
- self.orchestrator['requirements']['ram_min'])
- flavor_exist, flavor_id = os_utils.get_or_create_flavor(
- "m1.large",
- self.orchestrator['requirements']['ram_min'],
- '50',
- '2',
- public=True)
- self.logger.debug("Flavor id: %s", flavor_id)
-
- if not flavor_id:
- self.logger.info("Available flavors are: ")
- self.logger.info(self.nova_client.flavor.list())
-
- cfy.set_flavor_id(flavor_id)
- self.logger.debug("Flavor OK")
-
- # orchestrator VM image
- self.logger.debug("Orchestrator image")
- if 'os_image' in self.orchestrator['requirements'].keys():
- image_id = os_utils.get_image_id(
- self.glance_client,
- self.orchestrator['requirements']['os_image'])
- self.logger.debug("Orchestrator image id: %s", image_id)
- if image_id == '':
- self.logger.error("CFY image not found")
-
- cfy.set_image_id(image_id)
- self.logger.debug("Orchestrator image set")
-
- self.logger.debug("Get External network")
- ext_net = os_utils.get_external_net(self.neutron_client)
- self.logger.debug("External network: %s", ext_net)
-
- cfy.set_external_network_name(ext_net)
- self.logger.debug("CFY External network set")
-
- self.logger.debug("get resolvconf")
- ns = ft_utils.get_resolvconf_ns()
- if ns:
- cfy.set_nameservers(ns)
- self.logger.debug("Resolvconf set")
-
- self.logger.info("Prepare virtualenv for cloudify-cli")
- venv_scrit_dir = os.path.join(self.case_dir, "create_venv.sh")
- cmd = "bash {} {}".format(venv_scrit_dir, self.data_dir)
- ft_utils.execute_command(cmd)
-
- cfy.download_manager_blueprint(
- self.orchestrator['blueprint']['url'],
- self.orchestrator['blueprint']['branch'])
-
- error = cfy.deploy_manager()
- if error:
- self.logger.error(error)
- return {'status': 'FAIL', 'result': error}
+ self.__logger.info("Attemps running status of the Manager")
+ cfy_status = None
+ retry = 10
+ while str(cfy_status) != 'running' and retry:
+ try:
+ cfy_status = cfy_client.manager.get_status()['status']
+ except Exception: # pylint: disable=broad-except
+ self.__logger.warning("Cloudify Manager isn't " +
+ "up and running. Retrying ...")
+ retry = retry - 1
+ time.sleep(30)
+
+ if str(cfy_status) == 'running':
+ self.__logger.info("Cloudify Manager is up and running")
else:
- return {'status': 'PASS', 'result': ''}
+ raise Exception("Cloudify Manager isn't up and running")
+
+ self.__logger.info("Put OpenStack creds in manager")
+ secrets_list = cfy_client.secrets.list()
+ for k, val in cfy_creds.iteritems():
+ if not any(d.get('key', None) == k for d in secrets_list):
+ cfy_client.secrets.create(k, val)
+ else:
+ cfy_client.secrets.update(k, val)
+
+ duration = time.time() - start_time
+
+ self.__logger.info("Put private keypair in manager")
+ if manager_creator.vm_ssh_active(block=True):
+ ssh = manager_creator.ssh_client()
+ scp = SCPClient(ssh.get_transport())
+ scp.put(kp_file, '~/')
+ cmd = "sudo cp ~/cloudify_ims.pem /etc/cloudify/"
+ ssh.exec_command(cmd)
+ cmd = "sudo chmod 444 /etc/cloudify/cloudify_ims.pem"
+ ssh.exec_command(cmd)
+ cmd = "sudo yum install -y gcc python-devel"
+ ssh.exec_command(cmd)
+
+ self.details['orchestrator'].update(status='PASS', duration=duration)
+
+ self.vnf['inputs'].update(dict(
+ external_network_name=ext_net_name,
+ network_name=network_settings.name
+ ))
+ return True
def deploy_vnf(self):
- cw = Clearwater(self.vnf['inputs'], self.orchestrator['object'],
- self.logger)
- self.vnf['object'] = cw
-
- self.logger.info("Collect flavor id for all clearwater vm")
- flavor_exist, flavor_id = os_utils.get_or_create_flavor(
- "m1.small",
- self.vnf['requirements']['ram_min'],
+ """
+ Deploy Clearwater IMS
+ """
+ start_time = time.time()
+
+ self.__logger.info("Upload VNFD")
+ cfy_client = self.orchestrator['object']
+ descriptor = self.vnf['descriptor']
+ cfy_client.blueprints.publish_archive(descriptor.get('url'),
+ descriptor.get('name'),
+ descriptor.get('file_name'))
+
+ self.__logger.info("Get or create flavor for all clearwater vm")
+ self.exist_obj['flavor2'], flavor_id = os_utils.get_or_create_flavor(
+ self.vnf['requirements']['flavor']['name'],
+ self.vnf['requirements']['flavor']['ram_min'],
'30',
'1',
public=True)
- self.logger.debug("Flavor id: %s", flavor_id)
- if not flavor_id:
- self.logger.info("Available flavors are: ")
- self.logger.info(self.nova_client.flavor.list())
-
- cw.set_flavor_id(flavor_id)
-
- # VMs image
- if 'os_image' in self.vnf['requirements'].keys():
- image_id = os_utils.get_image_id(
- self.glance_client, self.vnf['requirements']['os_image'])
-
- cw.set_image_id(image_id)
- ext_net = os_utils.get_external_net(self.neutron_client)
- cw.set_external_network_name(ext_net)
-
- error = cw.deploy_vnf(self.vnf['blueprint'])
- if error:
- self.logger.error(error)
- return {'status': 'FAIL', 'result': error}
+
+ self.vnf['inputs'].update(dict(
+ flavor_id=flavor_id,
+ ))
+
+ self.__logger.info("Create VNF Instance")
+ cfy_client.deployments.create(descriptor.get('name'),
+ descriptor.get('name'),
+ self.vnf.get('inputs'))
+
+ wait_for_execution(cfy_client,
+ _get_deployment_environment_creation_execution(
+ cfy_client, descriptor.get('name')),
+ self.__logger,
+ timeout=600)
+
+ self.__logger.info("Start the VNF Instance deployment")
+ execution = cfy_client.executions.start(descriptor.get('name'),
+ 'install')
+ # Show execution log
+ execution = wait_for_execution(cfy_client, execution, self.__logger)
+
+ duration = time.time() - start_time
+
+ self.__logger.info(execution)
+ if execution.status == 'terminated':
+ self.details['vnf'].update(status='PASS', duration=duration)
+ return True
else:
- return {'status': 'PASS', 'result': ''}
+ self.details['vnf'].update(status='FAIL', duration=duration)
+ return False
def test_vnf(self):
- script = "source {0}venv_cloudify/bin/activate; "
- script += "cd {0}; "
- script += "cfy status | grep -Eo \"([0-9]{{1,3}}\.){{3}}[0-9]{{1,3}}\""
- cmd = "/bin/bash -c '" + script.format(self.data_dir) + "'"
+ """
+ Run test on clearwater ims instance
+ """
+ start_time = time.time()
- try:
- self.logger.debug("Trying to get clearwater manager IP ... ")
- mgr_ip = os.popen(cmd).read()
- mgr_ip = mgr_ip.splitlines()[0]
- except Exception:
- self.logger.exception("Unable to retrieve the IP of the "
- "cloudify manager server !")
-
- self.logger.info('Cloudify Manager: %s', mgr_ip)
- api_url = 'http://{0}/api/v2/deployments/{1}/outputs'.format(
- mgr_ip, self.vnf['deployment_name'])
- dep_outputs = requests.get(api_url)
- self.logger.info(api_url)
- outputs = dep_outputs.json()['outputs']
- self.logger.info("Deployment outputs: %s", outputs)
+ cfy_client = self.orchestrator['object']
+
+ outputs = cfy_client.deployments.outputs.get(
+ self.vnf['descriptor'].get('name'))['outputs']
dns_ip = outputs['dns_ip']
ellis_ip = outputs['ellis_ip']
self.config_ellis(ellis_ip)
if dns_ip != "":
vims_test_result = self.run_clearwater_live_test(
dns_ip=dns_ip,
- public_domain="") # self.inputs["public_domain"]
- if vims_test_result != '':
- return {'status': 'PASS', 'result': vims_test_result}
- else:
- return {'status': 'FAIL', 'result': ''}
+ public_domain=self.vnf['inputs']["public_domain"])
+ duration = time.time() - start_time
+ short_result = sig_test_format(vims_test_result)
+ self.__logger.info(short_result)
+ self.details['test_vnf'].update(status='PASS',
+ result=short_result,
+ full_result=vims_test_result,
+ duration=duration)
+ return True
+ else:
+ return False
def clean(self):
- self.vnf['object'].undeploy_vnf()
- self.orchestrator['object'].undeploy_manager()
+ try:
+ cfy_client = self.orchestrator['object']
+ dep_name = self.vnf['descriptor'].get('name')
+ # kill existing execution
+ self.__logger.info('Deleting the current deployment')
+ exec_list = cfy_client.executions.list(dep_name)
+ for execution in exec_list:
+ if execution['status'] == "started":
+ try:
+ cfy_client.executions.cancel(execution['id'],
+ force=True)
+ except:
+ self.__logger.warn("Can't cancel the current exec")
+
+ execution = cfy_client.executions.start(
+ dep_name,
+ 'uninstall',
+ parameters=dict(ignore_failure=True),
+ force=True)
+
+ wait_for_execution(cfy_client, execution, self.__logger)
+ cfy_client.deployments.delete(self.vnf['descriptor'].get('name'))
+ cfy_client.blueprints.delete(self.vnf['descriptor'].get('name'))
+ except:
+ self.__logger.warn("Some issue during the undeployment ..")
+ self.__logger.warn("Tenant clean continue ..")
+
+ self.__logger.info('Remove the cloudify manager OS object ..')
+ for creator in reversed(self.created_object):
+ try:
+ creator.clean()
+ except Exception as e:
+ self.logger.error('Unexpected error cleaning - %s', e)
super(CloudifyIms, self).clean()
# YAML UTILS
#
# -----------------------------------------------------------
-def get_config(parameter, file):
+def get_config(parameter, file_path):
"""
Returns the value of a given parameter in file.yaml
parameter must be given in string format with dots
Example: general.openstack.image_name
"""
- with open(file) as f:
- file_yaml = yaml.safe_load(f)
- f.close()
+ with open(file_path) as config_file:
+ file_yaml = yaml.safe_load(config_file)
+ config_file.close()
value = file_yaml
for element in parameter.split("."):
value = value.get(element)
raise ValueError("The parameter %s is not defined in"
" reporting.yaml" % parameter)
return value
+
+
+def wait_for_execution(client, execution, logger, timeout=2400, ):
+ """
+ Wait for a workflow execution on Cloudify Manager
+ """
+ # if execution already ended - return without waiting
+ if execution.status in Execution.END_STATES:
+ return execution
+
+ if timeout is not None:
+ deadline = time.time() + timeout
+
+ # Poll for execution status and execution logs, until execution ends
+ # and we receive an event of type in WORKFLOW_END_TYPES
+ offset = 0
+ batch_size = 50
+ event_list = []
+ execution_ended = False
+ while True:
+ event_list = client.events.list(
+ execution_id=execution.id,
+ _offset=offset,
+ _size=batch_size,
+ include_logs=False,
+ sort='@timestamp').items
+
+ offset = offset + len(event_list)
+ for event in event_list:
+ logger.debug(event.get('message'))
+
+ if timeout is not None:
+ if time.time() > deadline:
+ raise RuntimeError(
+ 'execution of operation {0} for deployment {1} '
+ 'timed out'.format(execution.workflow_id,
+ execution.deployment_id))
+ else:
+ # update the remaining timeout
+ timeout = deadline - time.time()
+
+ if not execution_ended:
+ execution = client.executions.get(execution.id)
+ execution_ended = execution.status in Execution.END_STATES
+
+ if execution_ended:
+ break
+
+ time.sleep(5)
+
+ return execution
+
+
+def _get_deployment_environment_creation_execution(client, deployment_id):
+ """
+ Get the execution id of a env preparation
+
+ network, security group, fip, VM creation
+ """
+ executions = client.executions.list(deployment_id=deployment_id)
+ for execution in executions:
+ if execution.workflow_id == 'create_deployment_environment':
+ return execution
+ raise RuntimeError('Failed to get create_deployment_environment '
+ 'workflow execution.'
+ 'Available executions: {0}'.format(executions))
+
+
+def sig_test_format(sig_test):
+ """
+ Process the signaling result to have a short result
+ """
+ nb_passed = 0
+ nb_failures = 0
+ nb_skipped = 0
+ for data_test in sig_test:
+ if data_test['result'] == "Passed":
+ nb_passed += 1
+ elif data_test['result'] == "Failed":
+ nb_failures += 1
+ elif data_test['result'] == "Skipped":
+ nb_skipped += 1
+ total_sig_test_result = {}
+ total_sig_test_result['passed'] = nb_passed
+ total_sig_test_result['failures'] = nb_failures
+ total_sig_test_result['skipped'] = nb_skipped
+ return total_sig_test_result
tenant_images:
ubuntu_14.04: http://cloud-images.ubuntu.com/trusty/current/trusty-server-cloudimg-amd64-disk1.img
- centos_7: http://cloud.centos.org/centos/7/images/CentOS-7-x86_64-GenericCloud-1510.qcow2
-cloudify:
- blueprint:
- url: https://github.com/boucherv-orange/cloudify-manager-blueprints.git
- branch: '3.3.1-build'
+ cloudify_manager_4.0: http://repository.cloudifysource.org/cloudify/4.0.1/sp-release/cloudify-manager-premium-4.0.1.qcow2
+orchestrator:
+ name: cloudify
+ version: '4.0'
requirements:
- ram_min: 4096
- os_image: centos_7
- inputs:
- keystone_username: ""
- keystone_password: ""
- keystone_tenant_name: ""
- keystone_url: ""
- manager_public_key_name: 'manager-kp'
- agent_public_key_name: 'agent-kp'
- image_id: ""
- flavor_id: "3"
- external_network_name: ""
- ssh_user: centos
- agents_user: ubuntu
-clearwater:
- blueprint:
+ flavor:
+ name: m1.medium
+ ram_min: 4096
+ os_image: 'cloudify_manager_4.0'
+vnf:
+ name: clearwater
+ version: '107'
+ descriptor:
file_name: openstack-blueprint.yaml
name: clearwater-opnfv
- destination_folder: opnfv-cloudify-clearwater
- url: https://github.com/Orange-OpenSource/opnfv-cloudify-clearwater.git
- branch: stable
- deployment_name: clearwater-opnfv
+ url: https://github.com/Orange-OpenSource/opnfv-cloudify-clearwater/archive/master.zip
+ version: '122'
requirements:
- ram_min: 2048
- os_image: ubuntu_14.04
+ flavor:
+ name: m1.medium
+ ram_min: 2048
inputs:
- image_id: ''
- flavor_id: ''
+ image_id: 'ubuntu_14.04'
+ flavor_id: 'm1.small'
agent_user: ubuntu
+ key_pair_name: cloudify_ims_kp
+ private_key_path: '/etc/cloudify/cloudify_ims.pem'
external_network_name: ''
public_domain: clearwater.opnfv
+ release: repo122
+ bono_cluster_size: 1
+ sprout_cluster_size: 1
+ vellum_cluster_size: 1
+ dime_cluster_size: 1
+ homer_cluster_size: 1
+vnf_test_suite:
+ name: clearwater-live-test
+ version: "1.0"
+++ /dev/null
-#!/bin/bash -e
-
-# Script checks that venv exists. If it doesn't it will be created
-# It requires python2.7 and virtualenv packages installed
-#
-# Copyright (c) 2015 Orange
-# valentin.boucher@orange.com
-#
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Apache License, Version 2.0
-# which accompanies this distribution, and is available at
-# http://www.apache.org/licenses/LICENSE-2.0
-
-BASEDIR=`dirname $0`
-VENV_PATH=$1
-VENV_NAME="venv_cloudify"
-function venv_install() {
- if command -v virtualenv-2.7; then
- virtualenv-2.7 $1
- elif command -v virtualenv2; then
- virtualenv2 $1
- elif command -v virtualenv; then
- virtualenv $1
- else
- echo Cannot find virtualenv command.
- return 1
- fi
-}
-
-# exit when something goes wrong during venv install
-set -e
-if [ ! -d "$VENV_PATH/$VENV_NAME" ]; then
- venv_install $VENV_PATH/$VENV_NAME
- echo "Virtualenv" + $VENV_NAME + "created."
-fi
-
-if [ ! -f "$VENV_PATH/$VENV_NAME/updated" -o $BASEDIR/requirements.pip -nt $VENV_PATH/$VENV_NAME/updated ]; then
- source $VENV_PATH/$VENV_NAME/bin/activate
- pip install -r $BASEDIR/requirements.pip
- touch $VENV_PATH/$VENV_NAME/updated
- echo "Requirements installed."
- deactivate
-fi
-set +e
+++ /dev/null
-#!/usr/bin/env python
-# coding: utf8
-#######################################################################
-#
-# Copyright (c) 2015 Orange
-# valentin.boucher@orange.com
-#
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Apache License, Version 2.0
-# which accompanies this distribution, and is available at
-# http://www.apache.org/licenses/LICENSE-2.0
-########################################################################
-
-import logging
-import os
-import shutil
-import subprocess32 as subprocess
-import yaml
-
-from git import Repo
-
-
-class Orchestrator(object):
-
- def __init__(self, testcase_dir, inputs={}):
- self.testcase_dir = testcase_dir
- self.blueprint_dir = testcase_dir + 'cloudify-manager-blueprint/'
- self.input_file = 'inputs.yaml'
- self.manager_blueprint = False
- self.config = inputs
- self.logger = logging.getLogger(__name__)
- self.manager_up = False
-
- def set_credentials(self, username, password, tenant_name, auth_url):
- self.config['keystone_username'] = username
- self.config['keystone_password'] = password
- self.config['keystone_url'] = auth_url
- self.config['keystone_tenant_name'] = tenant_name
-
- def set_flavor_id(self, flavor_id):
- self.config['flavor_id'] = flavor_id
-
- def set_image_id(self, image_id):
- self.config['image_id'] = image_id
-
- def set_external_network_name(self, external_network_name):
- self.config['external_network_name'] = external_network_name
-
- def set_ssh_user(self, ssh_user):
- self.config['ssh_user'] = ssh_user
-
- def set_nova_url(self, nova_url):
- self.config['nova_url'] = nova_url
-
- def set_neutron_url(self, neutron_url):
- self.config['neutron_url'] = neutron_url
-
- def set_nameservers(self, nameservers):
- if 0 < len(nameservers):
- self.config['dns_subnet_1'] = nameservers[0]
-
- def download_manager_blueprint(self, manager_blueprint_url,
- manager_blueprint_branch):
- if self.manager_blueprint:
- self.logger.info(
- "cloudify manager server blueprint is "
- "already downloaded !")
- else:
- self.logger.info(
- "Downloading the cloudify manager server blueprint")
- download_result = self._download_blueprints(
- manager_blueprint_url,
- manager_blueprint_branch,
- self.blueprint_dir)
-
- if not download_result:
- self.logger.error("Failed to download manager blueprint")
- exit(-1)
- else:
- self.manager_blueprint = True
-
- def manager_up(self):
- return self.manager_up
-
- def deploy_manager(self):
- if self.manager_blueprint:
- self.logger.info("Writing the inputs file")
- with open(self.blueprint_dir + "inputs.yaml", "w") as f:
- f.write(yaml.dump(self.config, default_style='"'))
- f.close()
-
- # Ensure no ssh key file already exists
- key_files = ["/.ssh/cloudify-manager-kp.pem",
- "/.ssh/cloudify-agent-kp.pem"]
- home = os.path.expanduser("~")
-
- for key_file in key_files:
- if os.path.isfile(home + key_file):
- os.remove(home + key_file)
-
- self.logger.info("Launching the cloudify-manager deployment")
- script = "set -e; "
- script += ("source " + self.testcase_dir +
- "venv_cloudify/bin/activate; ")
- script += "cd " + self.testcase_dir + "; "
- script += "cfy init -r; "
- script += "cd cloudify-manager-blueprint; "
- script += ("cfy local create-requirements -o requirements.txt " +
- "-p openstack-manager-blueprint.yaml; ")
- script += "pip install -r requirements.txt; "
- script += ("cfy bootstrap --install-plugins " +
- "-p openstack-manager-blueprint.yaml -i inputs.yaml; ")
- cmd = "/bin/bash -c '" + script + "'"
- error = execute_command(cmd, self.logger)
- if error:
- self.logger.error("Failed to deploy cloudify-manager")
- return error
-
- self.logger.info("Cloudify-manager server is UP !")
-
- self.manager_up = True
-
- def undeploy_manager(self):
- self.logger.info("Launching the cloudify-manager undeployment")
-
- self.manager_up = False
-
- script = "source " + self.testcase_dir + "venv_cloudify/bin/activate; "
- script += "cd " + self.testcase_dir + "; "
- script += "cfy teardown -f --ignore-deployments; "
- cmd = "/bin/bash -c '" + script + "'"
- execute_command(cmd, self.logger)
-
- self.logger.info(
- "Cloudify-manager server has been successfully removed!")
-
- def download_upload_and_deploy_blueprint(self, blueprint, config,
- bp_name, dep_name):
- self.logger.info("Downloading the {0} blueprint".format(
- blueprint['file_name']))
- destination_folder = os.path.join(self.testcase_dir,
- blueprint['destination_folder'])
- download_result = self._download_blueprints(blueprint['url'],
- blueprint['branch'],
- destination_folder)
-
- if not download_result:
- self.logger.error(
- "Failed to download blueprint {0}".
- format(blueprint['file_name']))
- exit(-1)
-
- self.logger.info("Writing the inputs file")
-
- with open(self.testcase_dir + blueprint['destination_folder'] +
- "/inputs.yaml", "w") as f:
- f.write(yaml.dump(config, default_style='"'))
- f.close()
-
- self.logger.info("Launching the {0} deployment".format(bp_name))
- script = "source " + self.testcase_dir + "venv_cloudify/bin/activate; "
- script += ("cd " + self.testcase_dir +
- blueprint['destination_folder'] + "; ")
- script += ("cfy blueprints upload -b " +
- bp_name + " -p openstack-blueprint.yaml; ")
- script += ("cfy deployments create -b " + bp_name +
- " -d " + dep_name + " --inputs inputs.yaml; ")
- script += ("cfy executions start -w install -d " +
- dep_name + " --timeout 1800; ")
-
- cmd = "/bin/bash -c '" + script + "'"
- error = execute_command(cmd, self.logger, 2000)
- if error:
- self.logger.error("Failed to deploy blueprint")
- return error
- self.logger.info("The deployment of {0} is ended".format(dep_name))
-
- def undeploy_deployment(self, dep_name):
- self.logger.info("Launching the {0} undeployment".format(dep_name))
- script = "source " + self.testcase_dir + "venv_cloudify/bin/activate; "
- script += "cd " + self.testcase_dir + "; "
- script += ("cfy executions start -w uninstall -d " + dep_name +
- " --timeout 1800 ; ")
- script += "cfy deployments delete -d " + dep_name + "; "
-
- cmd = "/bin/bash -c '" + script + "'"
- try:
- execute_command(cmd, self.logger)
- except:
- self.logger.error("Clearwater undeployment failed")
-
- def _download_blueprints(self, blueprint_url, branch, dest_path):
- if os.path.exists(dest_path):
- shutil.rmtree(dest_path)
- try:
- Repo.clone_from(blueprint_url, dest_path, branch=branch)
- return True
- except:
- return False
-
-
-def execute_command(cmd, logger, timeout=1800):
- """
- Execute Linux command
- """
- if logger:
- logger.debug('Executing command : {}'.format(cmd))
- timeout_exception = False
- output_file = "output.txt"
- f = open(output_file, 'w+')
- try:
- p = subprocess.call(cmd, shell=True, stdout=f,
- stderr=subprocess.STDOUT, timeout=timeout)
- except subprocess.TimeoutExpired:
- timeout_exception = True
- if logger:
- logger.error("TIMEOUT when executing command %s" % cmd)
- pass
-
- f.close()
- f = open(output_file, 'r')
- result = f.read()
- if result != "" and logger:
- logger.debug(result)
- if p == 0:
- return False
- else:
- if logger and not timeout_exception:
- logger.error("Error when executing command %s" % cmd)
- f = open(output_file, 'r')
- lines = f.readlines()
- return lines[-5:]
+++ /dev/null
-cloudify==3.3.1
\ No newline at end of file
-#!/usr/bin/env python
-
-# Copyright (c) 2016 Orange and others.
-#
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Apache License, Version 2.0
-# which accompanies this distribution, and is available at
-# http://www.apache.org/licenses/LICENSE-2.0
-
-# pylint: disable=missing-docstring
-
-import logging
-import unittest
-
-import mock
-
-from functest.core import vnf
-from functest.core import testcase
-from functest.utils import constants
-
-
-class VnfBaseTesting(unittest.TestCase):
- """The class testing VNF."""
- # pylint: disable=missing-docstring,too-many-public-methods
-
- tenant_name = 'test_tenant_name'
- tenant_description = 'description'
-
- def setUp(self):
- constants.CONST.__setattr__("vnf_foo_tenant_name", self.tenant_name)
- constants.CONST.__setattr__(
- "vnf_foo_tenant_description", self.tenant_description)
- self.test = vnf.VnfOnBoarding(project='functest', case_name='foo')
-
- def test_run_deploy_vnf_exc(self):
- with mock.patch.object(self.test, 'prepare'),\
- mock.patch.object(self.test, 'deploy_orchestrator',
- return_value=None), \
- mock.patch.object(self.test, 'deploy_vnf',
- side_effect=Exception):
- self.assertEqual(self.test.run(),
- testcase.TestCase.EX_TESTCASE_FAILED)
-
- def test_run_test_vnf_exc(self):
- with mock.patch.object(self.test, 'prepare'),\
- mock.patch.object(self.test, 'deploy_orchestrator',
- return_value=None), \
- mock.patch.object(self.test, 'deploy_vnf'), \
- mock.patch.object(self.test, 'test_vnf',
- side_effect=Exception):
- self.assertEqual(self.test.run(),
- testcase.TestCase.EX_TESTCASE_FAILED)
-
- def test_run_deploy_orch_ko(self):
- with mock.patch.object(self.test, 'prepare'),\
- mock.patch.object(self.test, 'deploy_orchestrator',
- return_value=False), \
- mock.patch.object(self.test, 'deploy_vnf',
- return_value=True), \
- mock.patch.object(self.test, 'test_vnf',
- return_value=True):
- self.assertEqual(self.test.run(),
- testcase.TestCase.EX_TESTCASE_FAILED)
-
- def test_run_vnf_deploy_ko(self):
- with mock.patch.object(self.test, 'prepare'),\
- mock.patch.object(self.test, 'deploy_orchestrator',
- return_value=True), \
- mock.patch.object(self.test, 'deploy_vnf',
- return_value=False), \
- mock.patch.object(self.test, 'test_vnf',
- return_value=True):
- self.assertEqual(self.test.run(),
- testcase.TestCase.EX_TESTCASE_FAILED)
-
- def test_run_vnf_test_ko(self):
- with mock.patch.object(self.test, 'prepare'),\
- mock.patch.object(self.test, 'deploy_orchestrator',
- return_value=True), \
- mock.patch.object(self.test, 'deploy_vnf',
- return_value=True), \
- mock.patch.object(self.test, 'test_vnf',
- return_value=False):
- self.assertEqual(self.test.run(),
- testcase.TestCase.EX_TESTCASE_FAILED)
-
- def test_run_default(self):
- with mock.patch.object(self.test, 'prepare'),\
- mock.patch.object(self.test, 'deploy_orchestrator',
- return_value=True), \
- mock.patch.object(self.test, 'deploy_vnf',
- return_value=True), \
- mock.patch.object(self.test, 'test_vnf',
- return_value=True):
- self.assertEqual(self.test.run(), testcase.TestCase.EX_OK)
-
- def test_deploy_vnf_unimplemented(self):
- with self.assertRaises(vnf.VnfDeploymentException):
- self.test.deploy_vnf()
-
- def test_test_vnf_unimplemented(self):
- with self.assertRaises(vnf.VnfTestException):
- self.test.test_vnf()
-
- @mock.patch('functest.core.vnf.os_utils.get_keystone_client')
- @mock.patch('functest.core.vnf.os_utils.delete_user',
- return_value=True)
- def test_clean_user_set(self, *args):
- self.test.user_created = True
- self.test.clean()
- args[0].assert_called_once_with(mock.ANY, self.tenant_name)
- args[1].assert_called_once_with()
-
- @mock.patch('functest.core.vnf.os_utils.get_keystone_client')
- @mock.patch('functest.core.vnf.os_utils.delete_user',
- return_value=True)
- def test_clean_user_unset(self, *args):
- self.test.user_created = False
- self.test.clean()
- args[0].assert_not_called()
- args[1].assert_called_once_with()
-
- @mock.patch('functest.core.vnf.os_utils.get_keystone_client')
- @mock.patch('functest.core.vnf.os_utils.delete_tenant',
- return_value=True)
- def test_clean_tenant_set(self, *args):
- self.test.tenant_created = True
- self.test.clean()
- args[0].assert_called_once_with(mock.ANY, self.tenant_name)
- args[1].assert_called_once_with()
-
- @mock.patch('functest.core.vnf.os_utils.get_keystone_client')
- @mock.patch('functest.core.vnf.os_utils.delete_tenant',
- return_value=True)
- def test_clean_tenant_unset(self, *args):
- self.test.tenant_created = False
- self.test.clean()
- args[0].assert_not_called()
- args[1].assert_called_once_with()
-
- def test_deploy_orch_unimplemented(self):
- self.assertTrue(self.test.deploy_orchestrator())
-
- @mock.patch('functest.core.vnf.os_utils.get_credentials',
- return_value={'creds': 'test'})
- @mock.patch('functest.core.vnf.os_utils.get_keystone_client',
- return_value='test')
- @mock.patch('functest.core.vnf.os_utils.get_or_create_tenant_for_vnf',
- return_value=0)
- @mock.patch('functest.core.vnf.os_utils.get_or_create_user_for_vnf',
- return_value=0)
- def test_prepare(self, *args):
- self.assertEqual(self.test.prepare(),
- testcase.TestCase.EX_OK)
- args[0].assert_called_once_with('test', self.tenant_name)
- args[1].assert_called_once_with(
- 'test', self.tenant_name, self.tenant_description)
- args[2].assert_called_once_with()
- args[3].assert_called_once_with()
-
- @mock.patch('functest.core.vnf.os_utils.get_credentials',
- side_effect=Exception)
- def test_prepare_admin_creds_ko(self, *args):
- with self.assertRaises(vnf.VnfPreparationException):
- self.test.prepare()
- args[0].assert_called_once_with()
-
- @mock.patch('functest.core.vnf.os_utils.get_credentials',
- return_value='creds')
- @mock.patch('functest.core.vnf.os_utils.get_keystone_client',
- side_effect=Exception)
- def test_prepare_keystone_client_ko(self, *args):
- with self.assertRaises(vnf.VnfPreparationException):
- self.test.prepare()
- args[0].assert_called_once_with()
- args[1].assert_called_once_with()
-
- @mock.patch('functest.core.vnf.os_utils.get_credentials',
- return_value='creds')
- @mock.patch('functest.core.vnf.os_utils.get_keystone_client')
- @mock.patch('functest.core.vnf.os_utils.get_or_create_tenant_for_vnf',
- side_effect=Exception)
- def test_prepare_tenant_creation_ko(self, *args):
- with self.assertRaises(vnf.VnfPreparationException):
- self.test.prepare()
- args[0].assert_called_once_with(
- mock.ANY, self.tenant_name, self.tenant_description)
- args[1].assert_called_once_with()
- args[2].assert_called_once_with()
-
- @mock.patch('functest.core.vnf.os_utils.get_credentials',
- return_value='creds')
- @mock.patch('functest.core.vnf.os_utils.get_keystone_client')
- @mock.patch('functest.core.vnf.os_utils.get_or_create_tenant_for_vnf',
- return_value=0)
- @mock.patch('functest.core.vnf.os_utils.get_or_create_user_for_vnf',
- side_effect=Exception)
- def test_prepare_user_creation_ko(self, *args):
- with self.assertRaises(vnf.VnfPreparationException):
- self.test.prepare()
- args[0].assert_called_once_with(mock.ANY, self.tenant_name)
- args[1].assert_called_once_with(
- mock.ANY, self.tenant_name, self.tenant_description)
- args[2].assert_called_once_with()
- args[3].assert_called_once_with()
-
-
-if __name__ == "__main__":
- logging.disable(logging.CRITICAL)
- unittest.main(verbosity=2)
+#!/usr/bin/env python\r
+\r
+# Copyright (c) 2016 Orange and others.\r
+#\r
+# All rights reserved. This program and the accompanying materials\r
+# are made available under the terms of the Apache License, Version 2.0\r
+# which accompanies this distribution, and is available at\r
+# http://www.apache.org/licenses/LICENSE-2.0\r
+\r
+# pylint: disable=missing-docstring\r
+\r
+import logging\r
+import unittest\r
+\r
+import mock\r
+\r
+from functest.core import vnf\r
+from functest.core import testcase\r
+from functest.utils import constants\r
+\r
+\r
+class VnfBaseTesting(unittest.TestCase):\r
+ """The class testing VNF."""\r
+ # pylint: disable=missing-docstring,too-many-public-methods\r
+\r
+ tenant_name = 'test_tenant_name'\r
+ tenant_description = 'description'\r
+\r
+ def setUp(self):\r
+ constants.CONST.__setattr__("vnf_foo_tenant_name", self.tenant_name)\r
+ constants.CONST.__setattr__(\r
+ "vnf_foo_tenant_description", self.tenant_description)\r
+ self.test = vnf.VnfOnBoarding(project='functest', case_name='foo')\r
+\r
+ def test_run_deploy_vnf_exc(self):\r
+ with mock.patch.object(self.test, 'prepare'),\\r
+ mock.patch.object(self.test, 'deploy_orchestrator',\r
+ return_value=None), \\r
+ mock.patch.object(self.test, 'deploy_vnf',\r
+ side_effect=Exception):\r
+ self.assertEqual(self.test.run(),\r
+ testcase.TestCase.EX_TESTCASE_FAILED)\r
+\r
+ def test_run_test_vnf_exc(self):\r
+ with mock.patch.object(self.test, 'prepare'),\\r
+ mock.patch.object(self.test, 'deploy_orchestrator',\r
+ return_value=None), \\r
+ mock.patch.object(self.test, 'deploy_vnf'), \\r
+ mock.patch.object(self.test, 'test_vnf',\r
+ side_effect=Exception):\r
+ self.assertEqual(self.test.run(),\r
+ testcase.TestCase.EX_TESTCASE_FAILED)\r
+\r
+ def test_run_deploy_orch_ko(self):\r
+ with mock.patch.object(self.test, 'prepare'),\\r
+ mock.patch.object(self.test, 'deploy_orchestrator',\r
+ return_value=False), \\r
+ mock.patch.object(self.test, 'deploy_vnf',\r
+ return_value=True), \\r
+ mock.patch.object(self.test, 'test_vnf',\r
+ return_value=True):\r
+ self.assertEqual(self.test.run(),\r
+ testcase.TestCase.EX_TESTCASE_FAILED)\r
+\r
+ def test_run_vnf_deploy_ko(self):\r
+ with mock.patch.object(self.test, 'prepare'),\\r
+ mock.patch.object(self.test, 'deploy_orchestrator',\r
+ return_value=True), \\r
+ mock.patch.object(self.test, 'deploy_vnf',\r
+ return_value=False), \\r
+ mock.patch.object(self.test, 'test_vnf',\r
+ return_value=True):\r
+ self.assertEqual(self.test.run(),\r
+ testcase.TestCase.EX_TESTCASE_FAILED)\r
+\r
+ def test_run_vnf_test_ko(self):\r
+ with mock.patch.object(self.test, 'prepare'),\\r
+ mock.patch.object(self.test, 'deploy_orchestrator',\r
+ return_value=True), \\r
+ mock.patch.object(self.test, 'deploy_vnf',\r
+ return_value=True), \\r
+ mock.patch.object(self.test, 'test_vnf',\r
+ return_value=False):\r
+ self.assertEqual(self.test.run(),\r
+ testcase.TestCase.EX_TESTCASE_FAILED)\r
+\r
+ def test_run_default(self):\r
+ with mock.patch.object(self.test, 'prepare'),\\r
+ mock.patch.object(self.test, 'deploy_orchestrator',\r
+ return_value=True), \\r
+ mock.patch.object(self.test, 'deploy_vnf',\r
+ return_value=True), \\r
+ mock.patch.object(self.test, 'test_vnf',\r
+ return_value=True):\r
+ self.assertEqual(self.test.run(), testcase.TestCase.EX_OK)\r
+\r
+ def test_deploy_vnf_unimplemented(self):\r
+ with self.assertRaises(vnf.VnfDeploymentException):\r
+ self.test.deploy_vnf()\r
+\r
+ def test_test_vnf_unimplemented(self):\r
+ with self.assertRaises(vnf.VnfTestException):\r
+ self.test.test_vnf()\r
+\r
+ @mock.patch('functest.core.vnf.os_utils.get_keystone_client')\r
+ @mock.patch('functest.core.vnf.os_utils.delete_user',\r
+ return_value=True)\r
+ def test_clean_user_already_exist(self, *args):\r
+ self.test.exist_obj['user'] = True\r
+ self.test.clean()\r
+ args[0].assert_not_called()\r
+ args[1].assert_called_once_with()\r
+\r
+ @mock.patch('functest.core.vnf.os_utils.get_keystone_client')\r
+ @mock.patch('functest.core.vnf.os_utils.delete_user',\r
+ return_value=True)\r
+ def test_clean_user_created(self, *args):\r
+ self.test.exist_obj['user'] = False\r
+ self.test.clean()\r
+ args[0].assert_called_once_with(mock.ANY, self.tenant_name)\r
+ args[1].assert_called_once_with()\r
+\r
+ @mock.patch('functest.core.vnf.os_utils.get_keystone_client')\r
+ @mock.patch('functest.core.vnf.os_utils.delete_tenant',\r
+ return_value=True)\r
+ def test_clean_tenant_already_exist(self, *args):\r
+ self.test.exist_obj['tenant'] = True\r
+ self.test.clean()\r
+ args[0].assert_not_called()\r
+ args[1].assert_called_once_with()\r
+\r
+ @mock.patch('functest.core.vnf.os_utils.get_keystone_client')\r
+ @mock.patch('functest.core.vnf.os_utils.delete_tenant',\r
+ return_value=True)\r
+ def test_clean_tenant_created(self, *args):\r
+ self.test.exist_obj['tenant'] = False\r
+ self.test.clean()\r
+ args[0].assert_called_once_with(mock.ANY, self.tenant_name)\r
+ args[1].assert_called_once_with()\r
+\r
+ def test_deploy_orch_unimplemented(self):\r
+ self.assertTrue(self.test.deploy_orchestrator())\r
+\r
+ @mock.patch('functest.core.vnf.os_utils.get_keystone_client',\r
+ return_value='test')\r
+ @mock.patch('functest.core.vnf.os_utils.get_or_create_tenant_for_vnf',\r
+ return_value=True)\r
+ @mock.patch('functest.core.vnf.os_utils.get_or_create_user_for_vnf',\r
+ return_value=True)\r
+ @mock.patch('functest.core.vnf.os_utils.get_credentials',\r
+ return_value={'auth_url': 'test'})\r
+ def test_prepare(self, *args):\r
+ self.assertEqual(self.test.prepare(),\r
+ testcase.TestCase.EX_OK)\r
+ args[0].assert_called_once_with()\r
+ args[1].assert_called_once_with('test', self.tenant_name)\r
+ args[2].assert_called_once_with(\r
+ 'test', self.tenant_name, self.tenant_description)\r
+ args[3].assert_called_once_with()\r
+\r
+ @mock.patch('functest.core.vnf.os_utils.get_keystone_client',\r
+ side_effect=Exception)\r
+ def test_prepare_keystone_client_ko(self, *args):\r
+ with self.assertRaises(vnf.VnfPreparationException):\r
+ self.test.prepare()\r
+ args[0].assert_called_once_with()\r
+\r
+ @mock.patch('functest.core.vnf.os_utils.get_keystone_client')\r
+ @mock.patch('functest.core.vnf.os_utils.get_or_create_tenant_for_vnf',\r
+ side_effect=Exception)\r
+ def test_prepare_tenant_creation_ko(self, *args):\r
+ with self.assertRaises(vnf.VnfPreparationException):\r
+ self.test.prepare()\r
+ args[0].assert_called_once_with(\r
+ mock.ANY, self.tenant_name, self.tenant_description)\r
+ args[1].assert_called_once_with()\r
+\r
+ @mock.patch('functest.core.vnf.os_utils.get_keystone_client')\r
+ @mock.patch('functest.core.vnf.os_utils.get_or_create_tenant_for_vnf',\r
+ return_value=0)\r
+ @mock.patch('functest.core.vnf.os_utils.get_or_create_user_for_vnf',\r
+ side_effect=Exception)\r
+ def test_prepare_user_creation_ko(self, *args):\r
+ with self.assertRaises(vnf.VnfPreparationException):\r
+ self.test.prepare()\r
+ args[0].assert_called_once_with(mock.ANY, self.tenant_name)\r
+ args[1].assert_called_once_with(\r
+ mock.ANY, self.tenant_name, self.tenant_description)\r
+ args[2].assert_called_once_with()\r
+\r
+\r
+if __name__ == "__main__":\r
+ logging.disable(logging.CRITICAL)\r
+ unittest.main(verbosity=2)\r
+++ /dev/null
-#!/usr/bin/env python
-
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Apache License, Version 2.0
-# which accompanies this distribution, and is available at
-# http://www.apache.org/licenses/LICENSE-2.0
-
-import logging
-import unittest
-
-import mock
-
-from functest.opnfv_tests.vnf.ims import clearwater
-from functest.opnfv_tests.vnf.ims import orchestrator_cloudify
-
-
-class ClearwaterTesting(unittest.TestCase):
-
- def setUp(self):
- self.clearwater = clearwater.Clearwater()
- self.orchestrator = orchestrator_cloudify.Orchestrator('test_dir')
- self.clearwater.orchestrator = self.orchestrator
- self.clearwater.dep_name = 'test_dep_name'
- self.bp = {'file_name': 'test_file',
- 'destination_folder': 'test_folder',
- 'url': 'test_url',
- 'branch': 'test_branch'}
-
- def test_deploy_vnf_blueprint_download_failed(self):
- with mock.patch.object(self.clearwater.orchestrator,
- 'download_upload_and_deploy_blueprint',
- return_value='error'):
- self.assertEqual(self.clearwater.deploy_vnf(self.bp),
- 'error')
-
- def test_deploy_vnf_blueprint_download_passed(self):
- with mock.patch.object(self.clearwater.orchestrator,
- 'download_upload_and_deploy_blueprint',
- return_value=''):
- self.clearwater.deploy_vnf(self.bp)
- self.assertEqual(self.clearwater.deploy, True)
-
- def test_undeploy_vnf_deployment_passed(self):
- with mock.patch.object(self.clearwater.orchestrator,
- 'undeploy_deployment'):
- self.clearwater.deploy = True
- self.clearwater.undeploy_vnf()
- self.assertEqual(self.clearwater.deploy, False)
-
- def test_undeploy_vnf_deployment_with_undeploy(self):
- with mock.patch.object(self.clearwater.orchestrator,
- 'undeploy_deployment') as m:
- self.clearwater.deploy = False
- self.clearwater.undeploy_vnf(),
- self.assertEqual(self.clearwater.deploy, False)
- self.assertFalse(m.called)
-
- self.clearwater.orchestrator = None
- self.clearwater.deploy = True
- self.clearwater.undeploy_vnf(),
- self.assertEqual(self.clearwater.deploy, True)
-
- self.clearwater.deploy = False
- self.clearwater.undeploy_vnf(),
- self.assertEqual(self.clearwater.deploy, False)
-
- def test_set_methods(self):
- self.clearwater.set_orchestrator(self.orchestrator)
- self.assertTrue(self.clearwater.orchestrator, self.orchestrator)
- self.clearwater.set_flavor_id('test_flavor_id')
- self.assertTrue(self.clearwater.config['flavor_id'], 'test_flavor_id')
- self.clearwater.set_image_id('test_image_id')
- self.assertTrue(self.clearwater.config['image_id'], 'test_image_id')
- self.clearwater.set_agent_user('test_user')
- self.assertTrue(self.clearwater.config['agent_user'], 'test_user')
- self.clearwater.set_external_network_name('test_network')
- self.assertTrue(self.clearwater.config['external_network_name'],
- 'test_network')
- self.clearwater.set_public_domain('test_domain')
- self.assertTrue(self.clearwater.config['public_domain'],
- 'test_domain')
-
-if __name__ == "__main__":
- logging.disable(logging.CRITICAL)
- unittest.main(verbosity=2)
-#!/usr/bin/env python
-
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Apache License, Version 2.0
-# which accompanies this distribution, and is available at
-# http://www.apache.org/licenses/LICENSE-2.0
-
-import logging
-import unittest
-
-import mock
-
-from functest.opnfv_tests.vnf.ims import cloudify_ims
-
-
-class CloudifyImsTesting(unittest.TestCase):
-
- def setUp(self):
- with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os.makedirs'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'get_config', return_value='config_value'):
- self.ims_vnf = cloudify_ims.CloudifyIms()
- self.neutron_client = mock.Mock()
- self.glance_client = mock.Mock()
- self.keystone_client = mock.Mock()
- self.nova_client = mock.Mock()
- self.orchestrator = {'requirements': {'ram_min': 2,
- 'os_image': 'test_os_image'},
- 'blueprint': {'url': 'test_url',
- 'branch': 'test_branch'},
- 'inputs': {'public_domain': 'test_domain'},
- 'object': 'test_object',
- 'deployment_name': 'test_deployment_name'}
- self.ims_vnf.orchestrator = self.orchestrator
- self.ims_vnf.images = {'test_image': 'test_url'}
- self.ims_vnf.vnf = self.orchestrator
- self.ims_vnf.tenant_name = 'test_tenant'
- self.ims_vnf.inputs = {'public_domain': 'test_domain'}
- self.ims_vnf.glance_client = self.glance_client
- self.ims_vnf.neutron_client = self.neutron_client
- self.ims_vnf.keystone_client = self.keystone_client
- self.ims_vnf.nova_client = self.nova_client
- self.ims_vnf.admin_creds = 'test_creds'
-
- self.mock_post = mock.Mock()
- attrs = {'status_code': 201,
- 'cookies': ""}
- self.mock_post.configure_mock(**attrs)
-
- self.mock_post_200 = mock.Mock()
- attrs = {'status_code': 200,
- 'cookies': ""}
- self.mock_post_200.configure_mock(**attrs)
-
- def test_deploy_orchestrator_missing_image(self):
- with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_neutron_client',
- return_value=self.neutron_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_glance_client',
- return_value=self.glance_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_keystone_client',
- return_value=self.keystone_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_nova_client',
- return_value=self.nova_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_image_id',
- return_value=''), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.os_utils.'
- 'download_and_add_image_on_glance') as m, \
- self.assertRaises(Exception) as context:
- self.ims_vnf.deploy_orchestrator()
- self.assertTrue(m.called)
- msg = "Failed to find or upload required OS "
- msg += "image for this deployment"
- self.assertTrue(msg in context.exception)
-
- def test_deploy_orchestrator_extend_quota_fail(self):
- with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_neutron_client',
- return_value=self.neutron_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_glance_client',
- return_value=self.glance_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_keystone_client',
- return_value=self.keystone_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_nova_client',
- return_value=self.nova_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_image_id',
- return_value='image_id'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_tenant_id',
- return_value='tenant_id'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.update_sg_quota',
- return_value=False), \
- self.assertRaises(Exception) as context:
- self.ims_vnf.deploy_orchestrator()
- msg = "Failed to update security group quota"
- msg += " for tenant test_tenant"
- self.assertTrue(msg in context.exception)
-
- def _get_image_id(self, client, name):
- if name == 'test_image':
- return 'image_id'
- else:
- return ''
-
- def test_deploy_orchestrator_missing_flavor(self):
- with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_neutron_client',
- return_value=self.neutron_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_glance_client',
- return_value=self.glance_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_keystone_client',
- return_value=self.keystone_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_nova_client',
- return_value=self.nova_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_image_id',
- side_effect=self._get_image_id), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_tenant_id',
- return_value='tenant_id'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.update_sg_quota',
- return_value=True), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_endpoint',
- return_value='public_auth_url'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'Orchestrator', return_value=mock.Mock()) as m, \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_or_create_flavor',
- return_value=(False, '')), \
- self.assertRaises(Exception) as context:
- self.ims_vnf.deploy_orchestrator()
- self.assertTrue(m.set_credentials.called)
- msg = "Failed to find required flavorfor this deployment"
- self.assertTrue(msg in context.exception)
-
- def test_deploy_orchestrator_missing_os_image(self):
- with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_neutron_client',
- return_value=self.neutron_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_glance_client',
- return_value=self.glance_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_keystone_client',
- return_value=self.keystone_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_nova_client',
- return_value=self.nova_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_image_id',
- side_effect=self._get_image_id), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_tenant_id',
- return_value='tenant_id'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.update_sg_quota',
- return_value=True), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_endpoint',
- return_value='public_auth_url'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'Orchestrator', return_value=mock.Mock()) as m, \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_or_create_flavor',
- return_value=(True, 'flavor_id')), \
- self.assertRaises(Exception) as context:
- self.ims_vnf.deploy_orchestrator()
- self.assertTrue(m.set_credentials.called)
- self.assertTrue(m.set_flavor_id.called)
- msg = "Failed to find required OS image for cloudify manager"
- self.assertTrue(msg in context.exception)
-
- def test_deploy_orchestrator_get_ext_network_fail(self):
- with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_neutron_client',
- return_value=self.neutron_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_glance_client',
- return_value=self.glance_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_keystone_client',
- return_value=self.keystone_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_nova_client',
- return_value=self.nova_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_image_id',
- return_value='image_id'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_tenant_id',
- return_value='tenant_id'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.update_sg_quota',
- return_value=True), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_endpoint',
- return_value='public_auth_url'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'Orchestrator', return_value=mock.Mock()) as m, \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_or_create_flavor',
- return_value=(True, 'flavor_id')), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_external_net',
- return_value=''), \
- self.assertRaises(Exception) as context:
- self.ims_vnf.deploy_orchestrator()
- self.assertTrue(m.set_credentials.called)
- self.assertTrue(m.set_flavor_id.called)
- self.assertTrue(m.set_image_id.called)
- msg = "Failed to get external network"
- self.assertTrue(msg in context.exception)
-
- def test_deploy_orchestrator_with_error(self):
- with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_neutron_client',
- return_value=self.neutron_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_glance_client',
- return_value=self.glance_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_keystone_client',
- return_value=self.keystone_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_nova_client',
- return_value=self.nova_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_image_id',
- return_value='image_id'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_tenant_id',
- return_value='tenant_id'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.update_sg_quota',
- return_value=True), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_endpoint',
- return_value='public_auth_url'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'Orchestrator') as m, \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_or_create_flavor',
- return_value=(True, 'flavor_id')), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_external_net',
- return_value='ext_net'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'ft_utils.get_resolvconf_ns',
- return_value=True), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'ft_utils.execute_command'):
- mock_obj = mock.Mock()
- attrs = {'deploy_manager.return_value': 'error'}
- mock_obj.configure_mock(**attrs)
-
- m.return_value = mock_obj
-
- self.assertEqual(self.ims_vnf.deploy_orchestrator(),
- {'status': 'FAIL', 'result': 'error'})
-
- def test_deploy_orchestrator_default(self):
- with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_neutron_client',
- return_value=self.neutron_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_glance_client',
- return_value=self.glance_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_keystone_client',
- return_value=self.keystone_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_nova_client',
- return_value=self.nova_client), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_image_id',
- return_value='image_id'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_tenant_id',
- return_value='tenant_id'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.update_sg_quota',
- return_value=True), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_endpoint',
- return_value='public_auth_url'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'Orchestrator') as m, \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_or_create_flavor',
- return_value=(True, 'flavor_id')), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_external_net',
- return_value='ext_net'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'ft_utils.get_resolvconf_ns',
- return_value=True), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'ft_utils.execute_command'):
- mock_obj = mock.Mock()
- attrs = {'deploy_manager.return_value': ''}
- mock_obj.configure_mock(**attrs)
-
- m.return_value = mock_obj
-
- self.assertEqual(self.ims_vnf.deploy_orchestrator(),
- {'status': 'PASS', 'result': ''})
-
- def test_deploy_vnf_missing_flavor(self):
- with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'Clearwater', return_value=mock.Mock()), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_or_create_flavor',
- return_value=(False, '')), \
- self.assertRaises(Exception) as context:
- self.ims_vnf.deploy_vnf()
- msg = "Failed to find required flavor for this deployment"
- self.assertTrue(msg in context.exception)
-
- def test_deploy_vnf_missing_os_image(self):
- with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'Clearwater', return_value=mock.Mock()) as m, \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_or_create_flavor',
- return_value=(True, 'test_flavor')), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_image_id',
- return_value=''), \
- self.assertRaises(Exception) as context:
- self.ims_vnf.deploy_vnf()
- msg = "Failed to find required OS image"
- msg += " for clearwater VMs"
- self.assertTrue(msg in context.exception)
- self.assertTrue(m.set_flavor_id.called)
-
- def test_deploy_vnf_missing_get_ext_net(self):
- with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'Clearwater', return_value=mock.Mock()) as m, \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_or_create_flavor',
- return_value=(True, 'test_flavor')), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_image_id',
- return_value='image_id'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_external_net',
- return_value=''), \
- self.assertRaises(Exception) as context:
- self.ims_vnf.deploy_vnf()
- msg = "Failed to get external network"
- self.assertTrue(msg in context.exception)
- self.assertTrue(m.set_flavor_id.called)
- self.assertTrue(m.set_image_id.called)
-
- def test_deploy_vnf_with_error(self):
- with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'Clearwater') as m, \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_or_create_flavor',
- return_value=(True, 'test_flavor')), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_image_id',
- return_value='image_id'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_external_net',
- return_value='ext_net'):
- mock_obj = mock.Mock()
- attrs = {'deploy_vnf.return_value': 'error'}
- mock_obj.configure_mock(**attrs)
-
- m.return_value = mock_obj
-
- self.assertEqual(self.ims_vnf.deploy_vnf(),
- {'status': 'FAIL', 'result': 'error'})
-
- def test_deploy_vnf_default(self):
- with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'Clearwater') as m, \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_or_create_flavor',
- return_value=(True, 'test_flavor')), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_image_id',
- return_value='image_id'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os_utils.get_external_net',
- return_value='ext_net'):
- mock_obj = mock.Mock()
- attrs = {'deploy_vnf.return_value': ''}
- mock_obj.configure_mock(**attrs)
-
- m.return_value = mock_obj
-
- self.assertEqual(self.ims_vnf.deploy_vnf(),
- {'status': 'PASS', 'result': ''})
-
- def test_test_vnf_ip_retrieval_failure(self):
- with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os.popen', side_effect=Exception), \
- self.assertRaises(Exception) as context:
- msg = "Unable to retrieve the IP of the "
- msg += "cloudify manager server !"
- self.ims_vnf.test_vnf()
- self.assertTrue(msg in context.exception)
-
- def test_test_vnf_fail(self):
- with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os.popen'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'requests.get') as mock_get, \
- mock.patch.object(self.ims_vnf, 'config_ellis'), \
- mock.patch.object(self.ims_vnf,
- 'run_clearwater_live_test') as clearwater_obj:
- clearwater_obj.return_value = ''
-
- mock_obj2 = mock.Mock()
- attrs = {'json.return_value': {'outputs':
- {'dns_ip': 'test_dns_ip',
- 'ellis_ip': 'test_ellis_ip'}}}
- mock_obj2.configure_mock(**attrs)
- mock_get.return_value = mock_obj2
-
- self.assertEqual(self.ims_vnf.test_vnf(),
- {'status': 'FAIL', 'result': ''})
-
- def test_test_vnf_pass(self):
- with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'os.popen'), \
- mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
- 'requests.get') as mock_get, \
- mock.patch.object(self.ims_vnf, 'config_ellis'), \
- mock.patch.object(self.ims_vnf,
- 'run_clearwater_live_test') as clearwater_obj:
- clearwater_obj.return_value = 'vims_test_result'
-
- mock_obj2 = mock.Mock()
- attrs = {'json.return_value': {'outputs':
- {'dns_ip': 'test_dns_ip',
- 'ellis_ip': 'test_ellis_ip'}}}
- mock_obj2.configure_mock(**attrs)
- mock_get.return_value = mock_obj2
-
- self.assertEqual(self.ims_vnf.test_vnf(),
- {'status': 'PASS',
- 'result': 'vims_test_result'})
-
-
-if __name__ == "__main__":
- logging.disable(logging.CRITICAL)
- unittest.main(verbosity=2)
+#!/usr/bin/env python\r
+\r
+# All rights reserved. This program and the accompanying materials\r
+# are made available under the terms of the Apache License, Version 2.0\r
+# which accompanies this distribution, and is available at\r
+# http://www.apache.org/licenses/LICENSE-2.0\r
+\r
+import logging\r
+import unittest\r
+\r
+import mock\r
+\r
+from functest.core import vnf\r
+from functest.opnfv_tests.vnf.ims import cloudify_ims\r
+\r
+\r
+class CloudifyImsTesting(unittest.TestCase):\r
+\r
+ def setUp(self):\r
+\r
+ self.tenant = 'cloudify_ims'\r
+ self.creds = {'username': 'user',\r
+ 'password': 'pwd'}\r
+ self.orchestrator = {'name': 'cloudify',\r
+ 'version': '4.0',\r
+ 'object': 'foo',\r
+ 'requirements': {'flavor': {'name': 'm1.medium',\r
+ 'ram_min': 4096},\r
+ 'os_image': 'manager_4.0'}}\r
+\r
+ self.vnf = {'name': 'clearwater',\r
+ 'descriptor': {'version': '108',\r
+ 'file_name': 'openstack-blueprint.yaml',\r
+ 'name': 'clearwater-opnfv',\r
+ 'url': 'https://foo',\r
+ 'requirements': {'flavor':\r
+ {'name': 'm1.medium',\r
+ 'ram_min': 2048}}}}\r
+\r
+ with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'\r
+ 'os.makedirs'), \\r
+ mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'\r
+ 'get_config', return_value={\r
+ 'tenant_images': 'foo',\r
+ 'orchestrator': self.orchestrator,\r
+ 'vnf': self.vnf,\r
+ 'vnf_test_suite': '',\r
+ 'version': 'whatever'}):\r
+\r
+ self.ims_vnf = cloudify_ims.CloudifyIms()\r
+\r
+ self.images = {'image1': 'url1',\r
+ 'image2': 'url2'}\r
+ self.details = {'orchestrator': {'status': 'PASS', 'duration': 120},\r
+ 'vnf': {},\r
+ 'test_vnf': {}}\r
+\r
+ @mock.patch('functest.core.vnf.os_utils.get_keystone_client',\r
+ return_value='test')\r
+ @mock.patch('functest.core.vnf.os_utils.get_or_create_tenant_for_vnf',\r
+ return_value=True)\r
+ @mock.patch('functest.core.vnf.os_utils.get_or_create_user_for_vnf',\r
+ return_value=True)\r
+ @mock.patch('functest.core.vnf.os_utils.get_credentials',\r
+ return_value={'auth_url': 'test/v1'})\r
+ @mock.patch('snaps.openstack.create_image.OpenStackImage.create')\r
+ def test_prepare_default(self, *args):\r
+ self.assertIsNone(self.ims_vnf.prepare())\r
+ args[4].assert_called_once_with()\r
+\r
+ @mock.patch('functest.core.vnf.os_utils.get_keystone_client',\r
+ return_value='test')\r
+ @mock.patch('functest.core.vnf.os_utils.get_or_create_tenant_for_vnf',\r
+ return_value=True)\r
+ @mock.patch('functest.core.vnf.os_utils.get_or_create_user_for_vnf',\r
+ return_value=True)\r
+ @mock.patch('functest.core.vnf.os_utils.get_credentials',\r
+ return_value={'auth_url': 'test/no_v'})\r
+ @mock.patch('snaps.openstack.create_image.OpenStackImage.create')\r
+ def test_prepare_bad_auth_url(self, *args):\r
+ with self.assertRaises(Exception):\r
+ self.ims_vnf.prepare()\r
+ args[0].assert_not_called()\r
+\r
+ def test_prepare_missing_param(self):\r
+ with self.assertRaises(vnf.VnfPreparationException):\r
+ self.ims_vnf.prepare()\r
+\r
+ @mock.patch('functest.core.vnf.os_utils.get_keystone_client',\r
+ side_effect=Exception)\r
+ def test_prepare_keystone_exception(self, *args):\r
+ with self.assertRaises(vnf.VnfPreparationException):\r
+ self.ims_vnf.prepare()\r
+ args[0].assert_called_once_with()\r
+\r
+ @mock.patch('functest.core.vnf.os_utils.get_keystone_client',\r
+ return_value='test')\r
+ @mock.patch('functest.core.vnf.os_utils.get_or_create_tenant_for_vnf',\r
+ side_effect=Exception)\r
+ def test_prepare_tenant_exception(self, *args):\r
+ with self.assertRaises(vnf.VnfPreparationException):\r
+ self.ims_vnf.prepare()\r
+ args[1].assert_called_once_with()\r
+\r
+ @mock.patch('functest.core.vnf.os_utils.get_keystone_client',\r
+ return_value='test')\r
+ @mock.patch('functest.core.vnf.os_utils.get_or_create_tenant_for_vnf',\r
+ return_value=True)\r
+ @mock.patch('functest.core.vnf.os_utils.get_or_create_user_for_vnf',\r
+ side_effect=Exception)\r
+ def test_prepare_user_exception(self, *args):\r
+ with self.assertRaises(vnf.VnfPreparationException):\r
+ self.ims_vnf.prepare()\r
+ args[2].assert_called_once_with()\r
+\r
+ @mock.patch('functest.core.vnf.os_utils.get_keystone_client',\r
+ return_value='test')\r
+ @mock.patch('functest.core.vnf.os_utils.get_or_create_tenant_for_vnf',\r
+ return_value=True)\r
+ @mock.patch('functest.core.vnf.os_utils.get_or_create_user_for_vnf',\r
+ return_value=True)\r
+ @mock.patch('functest.core.vnf.os_utils.get_credentials',\r
+ side_effect=Exception)\r
+ def test_prepare_credentials_exception(self, *args):\r
+ with self.assertRaises(vnf.VnfPreparationException):\r
+ self.ims_vnf.prepare()\r
+ args[0].assert_called_once_with()\r
+\r
+ # @mock.patch('snaps.openstack.create_keypairs.OpenStackKeypair',\r
+ # side_effect=Exception)\r
+ # def test_deploy_orchestrator_keypair_exception(self, *args):\r
+ # with self.assertRaises(vnf.OrchestratorDeploymentException):\r
+ # self.ims_vnf.deploy_orchestrator()\r
+\r
+ # def test_deploy_orchestrator_network_creation_fail(self):\r
+ # def test_deploy_orchestrator_floatting_ip_creation_fail(self):\r
+ # def test_deploy_orchestrator_flavor_fail(self):\r
+ # def test_deploy_orchestrator_get_image_id_fail(self):\r
+ # def test_deploy_orchestrator_create_instance_fail(self):\r
+ # def test_deploy_orchestrator_secgroup_fail(self):\r
+ # def test_deploy_orchestrator_add_floating_ip_fail(self):\r
+ # def test_deploy_orchestrator_get_endpoint_fail(self):\r
+ # def test_deploy_orchestrator_initiate CloudifyClient_fail(self):\r
+ # def test_deploy_orchestrator_get_status_fail(self):\r
+ #\r
+\r
+ # def test_deploy_vnf(self):\r
+ # def test_deploy_vnf_publish_fail(self):\r
+ # def test_deploy_vnf_get_flavor_fail(self):\r
+ # def test_deploy_vnf_get_external_net_fail(self):\r
+ # def test_deploy_vnf_deployment_create_fail(self):\r
+ # def test_deploy_vnf_start_fail(self):\r
+ #\r
+ # def test_test_vnf(self):\r
+ # def test_test_vnf_deployment_get_fail(self):\r
+ # def test_test_vnf_run_live_test_fail(self):\r
+ #\r
+ # def test_clean(self):\r
+ # def test_clean_execution_start_fail(self):\r
+ # def test_clean_deployment_delete_fail(self):\r
+ # def test_clean_blueprint_delete_fail(self):\r
+\r
+\r
+if __name__ == "__main__":\r
+ logging.disable(logging.CRITICAL)\r
+ unittest.main(verbosity=2)\r
+++ /dev/null
-#!/usr/bin/env python
-
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Apache License, Version 2.0
-# which accompanies this distribution, and is available at
-# http://www.apache.org/licenses/LICENSE-2.0
-
-import logging
-import subprocess32 as subprocess
-import unittest
-
-import mock
-
-from functest.opnfv_tests.vnf.ims import orchestrator_cloudify
-
-
-class ImsVnfTesting(unittest.TestCase):
-
- def setUp(self):
- self.orchestrator = orchestrator_cloudify.Orchestrator('test_dir')
- self.bp = {'file_name': 'test_file',
- 'destination_folder': 'test_folder',
- 'url': 'test_url',
- 'branch': 'test_branch'}
-
- def test_download_manager_blueprint_download_blueprint_failed(self):
- self.orchestrator.manager_blueprint = False
- with mock.patch.object(self.orchestrator, '_download_blueprints',
- return_value=False), \
- mock.patch('functest.opnfv_tests.vnf.ims.orchestrator_cloudify.'
- 'exit') as mock_exit:
- self.orchestrator.download_manager_blueprint('test_url',
- 'test_branch')
- mock_exit.assert_any_call(-1)
-
- def test_download_manager_blueprint_download_blueprint_passed(self):
- self.orchestrator.manager_blueprint = False
- with mock.patch.object(self.orchestrator, '_download_blueprints',
- return_value=True):
- self.orchestrator.download_manager_blueprint('test_url',
- 'test_branch')
- self.assertEqual(self.orchestrator.manager_blueprint,
- True)
-
- def test_deploy_manager_failed(self):
- self.orchestrator.manager_blueprint = True
- with mock.patch('__builtin__.open', mock.mock_open()), \
- mock.patch('functest.opnfv_tests.vnf.ims.orchestrator_cloudify.'
- 'os.remove'), \
- mock.patch('functest.opnfv_tests.vnf.ims.orchestrator_cloudify.'
- 'execute_command', return_value='error'):
- self.assertEqual(self.orchestrator.deploy_manager(),
- 'error')
- self.assertEqual(self.orchestrator.manager_up,
- False)
-
- def test_deploy_manager_passed(self):
- self.orchestrator.manager_blueprint = True
- with mock.patch('__builtin__.open', mock.mock_open()), \
- mock.patch('functest.opnfv_tests.vnf.ims.orchestrator_cloudify.'
- 'os.remove'), \
- mock.patch('functest.opnfv_tests.vnf.ims.orchestrator_cloudify.'
- 'execute_command', return_value=''):
- self.orchestrator.deploy_manager()
- self.assertEqual(self.orchestrator.manager_up,
- True)
-
- def test_undeploy_manager_passed(self):
- with mock.patch('functest.opnfv_tests.vnf.ims.orchestrator_cloudify.'
- 'execute_command', return_value=''):
- self.orchestrator.deploy_manager()
- self.assertEqual(self.orchestrator.manager_up,
- False)
-
- def test_dwnld_upload_and_depl_blueprint_dwnld_blueprint_failed(self):
- with mock.patch.object(self.orchestrator, '_download_blueprints',
- return_value=False), \
- mock.patch('functest.opnfv_tests.vnf.ims.orchestrator_cloudify.'
- 'exit', side_effect=Exception) as mock_exit, \
- self.assertRaises(Exception):
- self.orchestrator.download_upload_and_deploy_blueprint(self.bp,
- 'cfig',
- 'bpn',
- 'dpn')
- mock_exit.assert_any_call(-1)
-
- def test_dwnld_upload_and_depl_blueprint_failed(self):
- with mock.patch.object(self.orchestrator, '_download_blueprints',
- return_value=True), \
- mock.patch('__builtin__.open', mock.mock_open()), \
- mock.patch('functest.opnfv_tests.vnf.ims.orchestrator_cloudify.'
- 'execute_command', return_value='error'):
- r = self.orchestrator.download_upload_and_deploy_blueprint(self.bp,
- 'cfig',
- 'bpn',
- 'dpn')
- self.assertEqual(r, 'error')
-
- def test__download_blueprints_failed(self):
- with mock.patch('functest.opnfv_tests.vnf.ims.orchestrator_cloudify.'
- 'shutil.rmtree'), \
- mock.patch('functest.opnfv_tests.vnf.ims.orchestrator_cloudify.'
- 'Repo.clone_from', side_effect=Exception):
- self.assertEqual(self.orchestrator._download_blueprints('bp_url',
- 'branch',
- 'dest'),
- False)
-
- def test__download_blueprints_passed(self):
- with mock.patch('functest.opnfv_tests.vnf.ims.orchestrator_cloudify.'
- 'shutil.rmtree'), \
- mock.patch('functest.opnfv_tests.vnf.ims.orchestrator_cloudify.'
- 'Repo.clone_from'):
- self.assertEqual(self.orchestrator._download_blueprints('bp_url',
- 'branch',
- 'dest'),
- True)
-
- def test_execute_command_failed(self):
- with mock.patch('__builtin__.open',
- mock.mock_open(read_data='test_data\n')):
- subprocess.call = mock.create_autospec(subprocess.call,
- return_value=0)
- mock_log = mock.Mock()
- cmd = 'test_cmd -e test_env bash_script'
- ret = orchestrator_cloudify.execute_command(cmd, mock_log,
- timeout=100)
- self.assertEqual(ret, False)
-
- def test_execute_command_default(self):
- with mock.patch('__builtin__.open',
- mock.mock_open(read_data='test_data\n')):
- subprocess.call = mock. \
- create_autospec(subprocess.call,
- return_value=subprocess.TimeoutExpired)
- mock_log = mock.Mock()
- cmd = 'test_cmd -e test_env bash_script'
- ret = orchestrator_cloudify.execute_command(cmd, mock_log,
- timeout=100)
- self.assertEqual(ret, ['test_data\n'])
-
- def test_set_methods(self):
- self.orchestrator.set_credentials('test_username', 'test_password',
- 'test_tenant_name', 'test_auth_url')
- self.assertTrue(self.orchestrator.config['keystone_username'],
- 'test_username')
- self.assertTrue(self.orchestrator.config['keystone_password'],
- 'test_password')
- self.assertTrue(self.orchestrator.config['keystone_url'],
- 'test_auth_url')
- self.assertTrue(self.orchestrator.config['keystone_tenant_name'],
- 'test_tenant_name')
- self.orchestrator.set_flavor_id('test_flavor_id')
- self.assertTrue(self.orchestrator.config['flavor_id'],
- 'test_flavor_id')
- self.orchestrator.set_image_id('test_image_id')
- self.assertTrue(self.orchestrator.config['image_id'], 'test_image_id')
- self.orchestrator.set_external_network_name('test_network')
- self.assertTrue(self.orchestrator.config['external_network_name'],
- 'test_network')
- self.orchestrator.set_ssh_user('test_user')
- self.assertTrue(self.orchestrator.config['ssh_user'],
- 'test_user')
- self.orchestrator.set_nova_url('test_nova_url')
- self.assertTrue(self.orchestrator.config['nova_url'],
- 'test_nova_url')
- self.orchestrator.set_neutron_url('test_neutron_url')
- self.assertTrue(self.orchestrator.config['neutron_url'],
- 'test_neutron_url')
- self.orchestrator.set_nameservers(['test_subnet'])
- self.assertTrue(self.orchestrator.config['dns_subnet_1'],
- 'test_subnet')
-
-if __name__ == "__main__":
- logging.disable(logging.CRITICAL)
- unittest.main(verbosity=2)
def download_and_add_image_on_glance(glance, image_name, image_url, data_dir):
- dest_path = data_dir
- if not os.path.exists(dest_path):
- os.makedirs(dest_path)
- file_name = image_url.rsplit('/')[-1]
- if not ft_utils.download_url(image_url, dest_path):
- return False
-
- image = create_glance_image(
- glance, image_name, dest_path + file_name)
- if not image:
- return False
+ try:
+ dest_path = data_dir
+ if not os.path.exists(dest_path):
+ os.makedirs(dest_path)
+ file_name = image_url.rsplit('/')[-1]
+ if not ft_utils.download_url(image_url, dest_path):
+ return False
+ except Exception:
+ raise Exception("Impossible to download image from {}".format(
+ image_url))
- return image
+ try:
+ image = create_glance_image(
+ glance, image_name, dest_path + file_name)
+ if not image:
+ return False
+ else:
+ return image
+ except Exception:
+ raise Exception("Impossible to put image {} in glance".format(
+ image_name))
# *********************************************
flavor_id = create_flavor(
nova_client, flavor_name, ram, disk, vcpus, public=public)
if not flavor_id:
- logger.error("Failed to create flavor '%s'..." % (flavor_name))
+ raise Exception("Failed to create flavor '%s'..." % (flavor_name))
else:
logger.debug("Flavor '%s' with ID=%s created successfully."
% (flavor_name, flavor_id))
return None
-def create_neutron_subnet(neutron_client, name, cidr, net_id):
+def create_neutron_subnet(neutron_client, name, cidr, net_id,
+ dns=['8.8.8.8', '8.8.4.4']):
json_body = {'subnets': [{'name': name, 'cidr': cidr,
- 'ip_version': 4, 'network_id': net_id}]}
+ 'ip_version': 4, 'network_id': net_id,
+ 'dns_nameservers': dns}]}
+
try:
subnet = neutron_client.create_subnet(body=json_body)
return subnet['subnets'][0]['id']
net_name,
subnet_name,
router_name,
- cidr):
+ cidr,
+ dns=['8.8.8.8', '8.8.4.4']):
# Check if the network already exists
network_id = get_network_id(neutron_client, net_name)
logger.debug("Network '%s' created successfully" % network_id)
logger.debug('Creating Subnet....')
subnet_id = create_neutron_subnet(neutron_client, subnet_name,
- cidr, network_id)
+ cidr, network_id, dns)
if not subnet_id:
return None
try:
user_id = get_user_id(keystone_client, vnf_ref)
tenant_id = get_tenant_id(keystone_client, vnf_ref)
+ created = False
if not user_id:
user_id = create_user(keystone_client, vnf_ref, vnf_ref,
"", tenant_id)
- return True
- else:
- return False
- add_role_user(keystone_client, user_id, 'admin', vnf_ref)
+ created = True
+ try:
+ role_id = get_role_id(keystone_client, 'admin')
+ tenant_id = get_tenant_id(keystone_client, vnf_ref)
+ add_role_user(keystone_client, user_id, role_id, tenant_id)
+ except:
+ logger.warn("Cannot associate user to role admin on tenant")
+ return created
except:
raise Exception("Impossible to create a user for the VNF {}".format(
vnf_ref))
robotframework-requests==0.4.7
robotframework-sshlibrary==2.1.3;python_version=='2.7'
scp==0.10.2
-subprocess32;python_version=='2.7'
dnspython>=1.14.0;python_version=='2.7' # http://www.dnspython.org/LICENSE
dnspython3!=1.13.0,!=1.14.0,>=1.12.0;python_version>='3.0' # http://www.dnspython.org/LICENSE
click==6.6
openbaton-cli==2.2.1-beta7
+cloudify_rest_client==4.0
mock>=2.0 # BSD
iniparse==0.4
PrettyTable<0.8,>=0.7.1 # BSD
Code Review / functest.git / commitdiff