# which accompanies this distribution, and is available at
#
# http://www.apache.org/licenses/LICENSE-2.0
-import json
+import logging
import os
+import re
+import shlex
import shutil
+import subprocess
+import time
+import pkg_resources
import requests
-import functest.core.vnf_base as vnf_base
-from functest.utils.constants import CONST
-import functest.utils.functest_logger as ft_logger
+import functest.core.vnf as vnf
+from functest.utils import config
import functest.utils.functest_utils as ft_utils
+__author__ = ("Valentin Boucher <valentin.boucher@orange.com>, "
+ "Helen Yao <helanyao@gmail.com>")
-class ClearwaterOnBoardingBase(vnf_base.VnfOnBoardingBase):
- def __init__(self, project='functest', case='', repo='', cmd=''):
- self.logger = ft_logger.Logger(__name__).getLogger()
- super(ClearwaterOnBoardingBase, self).__init__(
- project, case, repo, cmd)
- self.case_dir = os.path.join(CONST.dir_functest_test, 'vnf', 'ims')
- self.data_dir = CONST.dir_ims_data
- self.result_dir = os.path.join(CONST.dir_results, case)
- self.test_dir = CONST.dir_repo_vims_test
+class ClearwaterOnBoardingBase(vnf.VnfOnBoarding):
+ """ vIMS clearwater base usable by several orchestrators"""
+
+ def __init__(self, **kwargs):
+ self.logger = logging.getLogger(__name__)
+ super(ClearwaterOnBoardingBase, self).__init__(**kwargs)
+ self.case_dir = pkg_resources.resource_filename(
+ 'functest', 'opnfv_tests/vnf/ims')
+ self.data_dir = getattr(config.CONF, 'dir_ims_data')
+ self.result_dir = os.path.join(getattr(config.CONF, 'dir_results'),
+ self.case_name)
+ self.test_dir = getattr(config.CONF, 'dir_repo_vims_test')
if not os.path.exists(self.data_dir):
os.makedirs(self.data_dir)
def config_ellis(self, ellis_ip, signup_code='secret', two_numbers=False):
output_dict = {}
- self.logger.info('Configure Ellis: %s', ellis_ip)
+ self.logger.debug('Configure Ellis: %s', ellis_ip)
output_dict['ellis_ip'] = ellis_ip
account_url = 'http://{0}/accounts'.format(ellis_ip)
params = {"password": "functest",
"full_name": "opnfv functest user",
"email": "functest@opnfv.org",
"signup_code": signup_code}
- rq = requests.post(account_url, data=params)
+ req = requests.post(account_url, data=params)
output_dict['login'] = params
- if rq.status_code != 201 and rq.status_code != 409:
- raise Exception("Unable to create an account for number provision")
- self.logger.info('Account is created on Ellis: %s', params)
+ if req.status_code != 201 and req.status_code != 409:
+ raise Exception(
+ "Unable to create an account {}\n{}".format(
+ params, req.text))
+ self.logger.debug(
+ 'Account %s is created on Ellis\n%s', params, req.json())
session_url = 'http://{0}/session'.format(ellis_ip)
session_data = {
'password': params['password'],
'email': params['email']
}
- rq = requests.post(session_url, data=session_data)
- if rq.status_code != 201:
- raise Exception('Failed to get cookie for Ellis')
- cookies = rq.cookies
- self.logger.info('Cookies: %s' % cookies)
+ req = requests.post(session_url, data=session_data)
+ if req.status_code != 201:
+ raise Exception('Failed to get cookie for Ellis\n{}'.format(
+ req.text))
+ cookies = req.cookies
+ self.logger.debug('Cookies: %s', cookies)
number_url = 'http://{0}/accounts/{1}/numbers'.format(
- ellis_ip,
- params['email'])
- self.logger.info('Create 1st calling number on Ellis')
- number_res = self.create_ellis_number(number_url, cookies)
+ ellis_ip, params['email'])
+ self.logger.debug('Create 1st calling number on Ellis')
+ i = 30
+ while req.status_code != 200 and i > 0:
+ try:
+ number_res = self._create_ellis_number(number_url, cookies)
+ break
+ except Exception: # pylint: disable=broad-except
+ if i == 1:
+ self.logger.exception("Unable to create a number")
+ raise Exception("Unable to create a number")
+ self.logger.info("Unable to create a number. Retry ..")
+ time.sleep(25)
+ i = i - 1
output_dict['number'] = number_res
if two_numbers:
- self.logger.info('Create 2nd calling number on Ellis')
- number_res = self.create_ellis_number(number_url, cookies)
+ self.logger.debug('Create 2nd calling number on Ellis')
+ number_res = self._create_ellis_number(number_url, cookies)
output_dict['number2'] = number_res
return output_dict
- def create_ellis_number(self, number_url, cookies):
- rq = requests.post(number_url, cookies=cookies)
+ def _create_ellis_number(self, number_url, cookies):
+ req = requests.post(number_url, cookies=cookies)
- if rq.status_code != 200:
- if rq and rq.json():
- reason = rq.json()['reason']
+ if req.status_code != 200:
+ if req and req.json():
+ reason = req.json()['reason']
else:
- reason = rq
+ reason = req
raise Exception("Unable to create a number: %s" % reason)
- number_res = rq.json()
+ number_res = req.json()
self.logger.info('Calling number is created: %s', number_res)
return number_res
def run_clearwater_live_test(self, dns_ip, public_domain,
bono_ip=None, ellis_ip=None,
signup_code='secret'):
+ # pylint: disable=too-many-locals,too-many-arguments
self.logger.info('Run Clearwater live test')
- nameservers = ft_utils.get_resolvconf_ns()
- resolvconf = ['{0}{1}{2}'.format(os.linesep, 'nameserver ', ns)
- for ns in nameservers]
- self.logger.debug('resolvconf: %s', resolvconf)
dns_file = '/etc/resolv.conf'
dns_file_bak = '/etc/resolv.conf.bak'
+ self.logger.debug('Backup %s -> %s', dns_file, dns_file_bak)
shutil.copy(dns_file, dns_file_bak)
- script = ('echo -e "nameserver {0}{1}" > {2};'
- 'source /etc/profile.d/rvm.sh;'
- 'cd {3};'
- 'rake test[{4}] SIGNUP_CODE={5}'
- .format(dns_ip,
- ''.join(resolvconf),
+ cmd = ("dnsmasq -d -u root --server=/clearwater.opnfv/{0} "
+ "-r /etc/resolv.conf.bak".format(dns_ip))
+ dnsmasq_process = subprocess.Popen(shlex.split(cmd))
+ script = ('echo -e "nameserver {0}" > {1};'
+ 'cd {2};'
+ 'rake test[{3}] SIGNUP_CODE={4}'
+ .format('127.0.0.1',
dns_file,
self.test_dir,
public_domain,
script = '{0}{1}'.format(script, subscript)
script = ('{0}{1}'.format(script, ' --trace'))
cmd = "/bin/bash -c '{0}'".format(script)
- self.logger.info('Live test cmd: %s', cmd)
+ self.logger.debug('Live test cmd: %s', cmd)
output_file = os.path.join(self.result_dir, "ims_test_output.txt")
ft_utils.execute_command(cmd,
error_msg='Clearwater live test failed',
output_file=output_file)
-
+ dnsmasq_process.kill()
with open(dns_file_bak, 'r') as bak_file:
result = bak_file.read()
- with open(dns_file, 'w') as f:
- f.write(result)
+ with open(dns_file, 'w') as dfile:
+ dfile.write(result)
+
+ with open(output_file, 'r') as ofile:
+ result = ofile.read()
- f = open(output_file, 'r')
- result = f.read()
if result != "":
self.logger.debug(result)
- vims_test_result = ""
- tempFile = os.path.join(self.test_dir, "temp.json")
+ vims_test_result = {}
try:
- self.logger.debug("Trying to load test results")
- with open(tempFile) as f:
- vims_test_result = json.load(f)
- f.close()
- except Exception:
- self.logger.error("Unable to retrieve test results")
-
- try:
- os.remove(tempFile)
- except Exception:
- self.logger.error("Deleting file failed")
-
+ grp = re.search(
+ r'(\d+) failures out of (\d+) tests run.*'
+ r'(\d+) tests skipped', result, re.MULTILINE | re.DOTALL)
+ assert grp
+ vims_test_result["failures"] = int(grp.group(1))
+ vims_test_result["total"] = int(grp.group(2))
+ vims_test_result["skipped"] = int(grp.group(3))
+ vims_test_result['passed'] = (
+ int(grp.group(2)) - int(grp.group(3)) - int(grp.group(1)))
+ except Exception: # pylint: disable=broad-except
+ self.logger.exception("Cannot parse live tests results")
+ return None
return vims_test_result
Code Review / functest.git / blobdiff