functest/opnfv_tests/openstack/refstack_client/refstack_client.py

   1 #!/usr/bin/env python
   2
   3 # matthew.lijun@huawei.com wangwulin@huawei.com
   4 # All rights reserved. This program and the accompanying materials
   5 # are made available under the terms of the Apache License, Version 2.0
   6 # which accompanies this distribution, and is available at
   7 # http://www.apache.org/licenses/LICENSE-2.0
   8 import argparse
   9 import os
  10 import re
  11 import sys
  12 import subprocess
  13 import time
  14
  15 from functest.core import testcase_base
  16 from functest.opnfv_tests.openstack.tempest import conf_utils
  17 from functest.utils import openstack_utils
  18 from functest.utils.constants import CONST
  19 import functest.utils.functest_logger as ft_logger
  20 import functest.utils.functest_utils as ft_utils
  21
  22 """ logging configuration """
  23 logger = ft_logger.Logger("refstack_defcore").getLogger()
  24
  25
  26 class RefstackClient(testcase_base.TestcaseBase):
  27
  28     def __init__(self):
  29         super(RefstackClient, self).__init__()
  30         self.case_name = "refstack_defcore"
  31         self.FUNCTEST_TEST = CONST.dir_functest_test
  32         self.CONF_PATH = CONST.refstack_tempest_conf_path
  33         self.DEFCORE_LIST = CONST.refstack_defcore_list
  34         self.confpath = os.path.join(self.FUNCTEST_TEST,
  35                                      self.CONF_PATH)
  36         self.defcorelist = os.path.join(self.FUNCTEST_TEST,
  37                                         self.DEFCORE_LIST)
  38         self.VERIFIER_ID = conf_utils.get_verifier_id()
  39         self.VERIFIER_REPO_DIR = conf_utils.get_verifier_repo_dir(
  40             self.VERIFIER_ID)
  41         self.DEPLOYMENT_ID = conf_utils.get_verifier_deployment_id()
  42         self.DEPLOYMENT_DIR = conf_utils.get_verifier_deployment_dir(
  43             self.VERIFIER_ID, self.DEPLOYMENT_ID)
  44
  45     def source_venv(self):
  46
  47         cmd = ("cd {0};"
  48                ". .venv/bin/activate;"
  49                "cd -;".format(CONST.dir_refstack_client))
  50         ft_utils.execute_command(cmd)
  51
  52     def run_defcore(self, conf, testlist):
  53         logger.debug("Generating test case list...")
  54
  55         cmd = ("cd {0};"
  56                "./refstack-client test -c {1} -v --test-list {2};"
  57                "cd -;".format(CONST.dir_refstack_client,
  58                               conf,
  59                               testlist))
  60         ft_utils.execute_command(cmd)
  61
  62     def run_defcore_default(self):
  63         logger.debug("Generating test case list...")
  64
  65         cmd = ("cd {0};"
  66                "./refstack-client test -c {1} -v --test-list {2};"
  67                "cd -;".format(CONST.dir_refstack_client,
  68                               self.confpath,
  69                               self.defcorelist))
  70         logger.info("Starting Refstack_defcore test case: '%s'." % cmd)
  71
  72         header = ("Tempest environment:\n"
  73                   "  Installer: %s\n  Scenario: %s\n  Node: %s\n  Date: %s\n" %
  74                   (CONST.INSTALLER_TYPE,
  75                    CONST.DEPLOY_SCENARIO,
  76                    CONST.NODE_NAME,
  77                    time.strftime("%a %b %d %H:%M:%S %Z %Y")))
  78
  79         f_stdout = open(
  80             os.path.join(conf_utils.REFSTACK_RESULTS_DIR,
  81                          "refstack.log"), 'w+')
  82         f_stderr = open(
  83             os.path.join(conf_utils.REFSTACK_RESULTS_DIR,
  84                          "refstack-error.log"), 'w+')
  85         f_env = open(os.path.join(conf_utils.REFSTACK_RESULTS_DIR,
  86                                   "environment.log"), 'w+')
  87         f_env.write(header)
  88
  89         p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,
  90                              stderr=f_stderr, bufsize=1)
  91
  92         with p.stdout:
  93             for line in iter(p.stdout.readline, b''):
  94                 if 'Tests' in line:
  95                     break
  96                 logger.info(line.replace('\n', ''))
  97                 f_stdout.write(line)
  98         p.wait()
  99
 100         f_stdout.close()
 101         f_stderr.close()
 102         f_env.close()
 103
 104     def parse_refstack_result(self):
 105         try:
 106             with open(os.path.join(conf_utils.REFSTACK_RESULTS_DIR,
 107                                    "refstack.log"), 'r') as logfile:
 108                 output = logfile.read()
 109
 110             for match in re.findall("Ran: (\d+) tests in (\d+\.\d{4}) sec.",
 111                                     output):
 112                 num_tests = match[0]
 113             for match in re.findall("- Passed: (\d+)", output):
 114                 num_success = match
 115             for match in re.findall("- Skipped: (\d+)", output):
 116                 num_skipped = match
 117             for match in re.findall("- Failed: (\d+)", output):
 118                 num_failures = match
 119             success_testcases = ""
 120             for match in re.findall(r"\{0\}(.*?)[. ]*ok", output):
 121                 success_testcases += match + ", "
 122             failed_testcases = ""
 123             for match in re.findall(r"\{0\}(.*?)[. ]*FAILED", output):
 124                 failed_testcases += match + ", "
 125             skipped_testcases = ""
 126             for match in re.findall(r"\{0\}(.*?)[. ]*SKIPPED:", output):
 127                 skipped_testcases += match + ", "
 128
 129             num_executed = int(num_tests) - int(num_skipped)
 130             success_rate = 100 * int(num_success) / int(num_executed)
 131
 132             self.details = {"num_tests": int(num_tests),
 133                             "num_failures": int(num_failures),
 134                             "success": success_testcases,
 135                             "failed": failed_testcases,
 136                             "skipped": skipped_testcases}
 137         except Exception:
 138             success_rate = 0
 139
 140         self.criteria = ft_utils.check_success_rate(
 141             self.case_name, success_rate)
 142         logger.info("Testcase %s success_rate is %s%%, is marked as %s"
 143                     % (self.case_name, success_rate, self.criteria))
 144
 145     def defcore_env_prepare(self):
 146         try:
 147             img_flavor_dict = conf_utils.create_tempest_resources(
 148                 use_custom_images=True, use_custom_flavors=True)
 149             conf_utils.configure_tempest_defcore(
 150                 self.DEPLOYMENT_DIR, img_flavor_dict)
 151             self.source_venv()
 152             res = testcase_base.TestcaseBase.EX_OK
 153         except KeyError as e:
 154             logger.error("defcore prepare env error with: %s", e)
 155             res = testcase_base.TestcaseBase.EX_RUN_ERROR
 156
 157         return res
 158
 159     def run(self):
 160         self.start_time = time.time()
 161
 162         if not os.path.exists(conf_utils.REFSTACK_RESULTS_DIR):
 163             os.makedirs(conf_utils.REFSTACK_RESULTS_DIR)
 164
 165         try:
 166             self.defcore_env_prepare()
 167             self.run_defcore_default()
 168             self.parse_refstack_result()
 169             res = testcase_base.TestcaseBase.EX_OK
 170         except Exception as e:
 171             logger.error('Error with run: %s', e)
 172             res = testcase_base.TestcaseBase.EX_RUN_ERROR
 173
 174         self.stop_time = time.time()
 175         return res
 176
 177     def main(self, **kwargs):
 178         try:
 179             tempestconf = kwargs['config']
 180             testlist = kwargs['testlist']
 181         except KeyError as e:
 182             logger.error("Cannot run refstack client. Please check "
 183                          "%s", e)
 184             return self.EX_RUN_ERROR
 185         try:
 186             openstack_utils.source_credentials(CONST.openstack_creds)
 187             self.defcore_env_prepare()
 188             self.run_defcore(tempestconf, testlist)
 189             res = testcase_base.TestcaseBase.EX_OK
 190         except Exception as e:
 191             logger.error('Error with run: %s', e)
 192             res = testcase_base.TestcaseBase.EX_RUN_ERROR
 193
 194         return res
 195
 196
 197 class RefstackClientParser(testcase_base.TestcaseBase):
 198
 199     def __init__(self):
 200         super(RefstackClientParser, self).__init__()
 201         self.FUNCTEST_TEST = CONST.dir_functest_test
 202         self.CONF_PATH = CONST.refstack_tempest_conf_path
 203         self.DEFCORE_LIST = CONST.refstack_defcore_list
 204         self.confpath = os.path.join(self.FUNCTEST_TEST,
 205                                      self.CONF_PATH)
 206         self.defcorelist = os.path.join(self.FUNCTEST_TEST,
 207                                         self.DEFCORE_LIST)
 208         self.parser = argparse.ArgumentParser()
 209         self.parser.add_argument(
 210             '-c', '--config',
 211             help='the file path of tempest.conf',
 212             default=self.confpath)
 213         self.parser.add_argument(
 214             '-t', '--testlist',
 215             help='Specify the file path or URL of a test list text file. '
 216                  'This test list will contain specific test cases that '
 217                  'should be tested.',
 218             default=self.defcorelist)
 219
 220     def parse_args(self, argv=[]):
 221         return vars(self.parser.parse_args(argv))
 222
 223
 224 if __name__ == '__main__':
 225     refstackclient = RefstackClient()
 226     parser = RefstackClientParser()
 227     args = parser.parse_args(sys.argv[1:])
 228     try:
 229         result = refstackclient.main(**args)
 230         if result != testcase_base.TestcaseBase.EX_OK:
 231             sys.exit(result)
 232     except Exception:
 233         sys.exit(testcase_base.TestcaseBase.EX_RUN_ERROR)