X-Git-Url: https://gerrit.opnfv.org/gerrit/gitweb?a=blobdiff_plain;f=functest%2Fopnfv_tests%2Fvnf%2Fims%2Fclearwater.py;h=96f1b40c6072d42e2d7fc38104a572593aae075d;hb=026a9bfaa656d0e5ade327feda64f17796d6f209;hp=32c6dc5c9c67cbe0bd1432ca425b7dad90088672;hpb=48fc7087653384cc83a6f89fa984ad6281e1752b;p=functest.git

diff --git a/functest/opnfv_tests/vnf/ims/clearwater.py b/functest/opnfv_tests/vnf/ims/clearwater.py
index 32c6dc5c9..96f1b40c6 100644
--- a/functest/opnfv_tests/vnf/ims/clearwater.py
+++ b/functest/opnfv_tests/vnf/ims/clearwater.py
@@ -1,66 +1,213 @@
-#!/usr/bin/python
-# coding: utf8
-#######################################################################
+#!/usr/bin/env python
 #
-#   Copyright (c) 2015 Orange
-#   valentin.boucher@orange.com
-#
-# All rights reserved. This program and the accompanying materials
+# Copyright (c) 2017 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
-########################################################################
 
+"""Ease testing any Clearwater deployment"""
+
+import logging
+import os
+import re
+import shlex
+import shutil
+import subprocess
+import time
+
+import pkg_resources
+import requests
+
+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 ClearwaterTesting(object):
+    """vIMS clearwater base usable by several orchestrators"""
+
+    def __init__(self, case_name, ellis_ip):
+        self.logger = logging.getLogger(__name__)
+        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'), 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)
+        if not os.path.exists(self.result_dir):
+            os.makedirs(self.result_dir)
+
+        self.ellis_ip = ellis_ip
+
+    def availability_check_by_creating_numbers(self,
+                                               signup_code='secret',
+                                               two_numbers=False):
+        """Create one or two numbers"""
+        assert self.ellis_ip
+        output_dict = {}
+        self.logger.debug('Ellis IP: %s', self.ellis_ip)
+        output_dict['ellis_ip'] = self.ellis_ip
+        account_url = 'http://{0}/accounts'.format(self.ellis_ip)
+        params = {"password": "functest",
+                  "full_name": "opnfv functest user",
+                  "email": "functest@opnfv.org",
+                  "signup_code": signup_code}
+        output_dict['login'] = params
+
+        number_res = self._create_ellis_account(account_url, params)
+        output_dict['number'] = number_res
+
+        session_url = 'http://{0}/session'.format(self.ellis_ip)
+        session_data = {
+            'username': params['email'],
+            'password': params['password'],
+            'email': params['email']
+        }
+        cookies = self._get_ellis_session_cookies(session_url, session_data)
 
-class Clearwater(object):
+        number_url = 'http://{0}/accounts/{1}/numbers'.format(
+            self.ellis_ip, params['email'])
+        self.logger.debug('Create 1st calling number on Ellis')
+        number_res = self._create_ellis_number(number_url, cookies)
 
-    def __init__(self, inputs={}, orchestrator=None, logger=None):
-        self.config = inputs
-        self.orchestrator = orchestrator
-        self.logger = logger
-        self.deploy = False
+        if two_numbers:
+            self.logger.debug('Create 2nd calling number on Ellis')
+            number_res = self._create_ellis_number(number_url, cookies)
+            output_dict['number2'] = number_res
 
-    def set_orchestrator(self, orchestrator):
-        self.orchestrator = orchestrator
+        return output_dict
 
-    def set_flavor_id(self, flavor_id):
-        self.config['flavor_id'] = flavor_id
+    def _create_ellis_account(self, account_url, params):
+        i = 50
+        for iloop in range(i):
+            try:
+                req = requests.post(account_url, data=params)
+                if req.status_code == 201:
+                    account_res = req.json()
+                    self.logger.info(
+                        'Account %s is created on Ellis\n%s',
+                        params.get('full_name'), account_res)
+                    return account_res
+                else:
+                    raise Exception("Cannot create ellis account")
+            except Exception:  # pylint: disable=broad-except
+                self.logger.info(
+                    "try %s: cannot create ellis account", iloop + 1)
+                time.sleep(25)
+        raise Exception(
+            "Unable to create an account {}".format(
+                params.get('full_name')))
 
-    def set_image_id(self, image_id):
-        self.config['image_id'] = image_id
+    def _get_ellis_session_cookies(self, session_url, params):
+        i = 15
+        for iloop in range(i):
+            try:
+                req = requests.post(session_url, data=params)
+                if req.status_code == 201:
+                    cookies = req.cookies
+                    self.logger.debug('cookies: %s', cookies)
+                    return cookies
+                else:
+                    raise Exception('Failed to get cookies for Ellis')
+            except Exception:  # pylint: disable=broad-except
+                self.logger.info(
+                    "try %s: cannot get cookies for Ellis", iloop + 1)
+                time.sleep(10)
+        raise Exception('Failed to get cookies for Ellis')
 
-    def set_agent_user(self, agent_user):
-        self.config['agent_user'] = agent_user
+    def _create_ellis_number(self, number_url, cookies):
+        i = 30
+        for iloop in range(i):
+            try:
+                req = requests.post(number_url, cookies=cookies)
+                if req.status_code == 200:
+                    number_res = req.json()
+                    self.logger.info(
+                        'Calling number is created: %s', number_res)
+                    return number_res
+                else:
+                    if req and req.json():
+                        reason = req.json()['reason']
+                    else:
+                        reason = req
+                    self.logger.info("cannot create a number: %s", reason)
+                    raise Exception('Failed to create a number')
+            except Exception:  # pylint: disable=broad-except
+                self.logger.info(
+                    "try %s: cannot create a number", iloop + 1)
+                time.sleep(25)
+        raise Exception('Failed to create a number')
 
-    def set_external_network_name(self, external_network_name):
-        self.config['external_network_name'] = external_network_name
+    def run_clearwater_live_test(self, dns_ip, public_domain,
+                                 bono_ip=None, ellis_ip=None,
+                                 signup_code='secret'):
+        """Run the Clearwater live tests
 
-    def set_public_domain(self, public_domain):
-        self.config['public_domain'] = public_domain
+        It first runs dnsmasq to reach clearwater services by FQDN and then the
+        Clearwater live tests. All results are saved in ims_test_output.txt.
 
-    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
+        Returns:
+            - a dict containing the overall results
+            - None on error
+        """
+        # pylint: disable=too-many-locals,too-many-arguments
+        self.logger.info('Run Clearwater live test')
+        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)
+        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,
+                          signup_code))
+        if bono_ip and ellis_ip:
+            subscript = ' PROXY={0} ELLIS={1}'.format(bono_ip, ellis_ip)
+            script = '{0}{1}'.format(script, subscript)
+        script = ('{0}{1}'.format(script, ' --trace'))
+        cmd = "/bin/bash -c '{0}'".format(script)
+        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 dfile:
+                dfile.write(result)
 
-            self.deploy = True
+        with open(output_file, 'r') as ofile:
+            result = ofile.read()
 
-        else:
-            if self.logger:
-                self.logger.error("Cloudify manager is down or not provide...")
+        if result != "":
+            self.logger.debug(result)
 
-    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...")
+        vims_test_result = {}
+        try:
+            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