functest/core/vnf.py

   1 #!/usr/bin/env python
   2
   3 # Copyright (c) 2016 Orange and others.
   4 #
   5 # All rights reserved. This program and the accompanying materials
   6 # are made available under the terms of the Apache License, Version 2.0
   7 # which accompanies this distribution, and is available at
   8 # http://www.apache.org/licenses/LICENSE-2.0
   9
  10 """Define the parent class of all VNF TestCases."""
  11
  12 import logging
  13 import time
  14
  15 import functest.core.testcase as base
  16 from functest.utils.constants import CONST
  17 from snaps.openstack.create_user import UserSettings, OpenStackUser
  18 from snaps.openstack.create_project import ProjectSettings, OpenStackProject
  19 from snaps.openstack.tests import openstack_tests
  20
  21 __author__ = ("Morgan Richomme <morgan.richomme@orange.com>, "
  22               "Valentin Boucher <valentin.boucher@orange.com>")
  23
  24
  25 class VnfPreparationException(Exception):
  26     """Raise when VNF preparation cannot be executed."""
  27
  28
  29 class OrchestratorDeploymentException(Exception):
  30     """Raise when orchestrator cannot be deployed."""
  31
  32
  33 class VnfDeploymentException(Exception):
  34     """Raise when VNF cannot be deployed."""
  35
  36
  37 class VnfTestException(Exception):
  38     """Raise when VNF cannot be tested."""
  39
  40
  41 class VnfOnBoarding(base.TestCase):
  42     """Base model for VNF test cases."""
  43
  44     __logger = logging.getLogger(__name__)
  45
  46     def __init__(self, **kwargs):
  47         super(VnfOnBoarding, self).__init__(**kwargs)
  48         self.tenant_name = CONST.__getattribute__(
  49             'vnf_{}_tenant_name'.format(self.case_name))
  50         self.snaps_creds = {}
  51         self.created_object = []
  52         self.os_project = None
  53
  54     def run(self, **kwargs):
  55         """
  56         Run of the VNF test case:
  57
  58             * Deploy an orchestrator if needed (e.g. heat, cloudify, ONAP),
  59             * Deploy the VNF,
  60             * Perform tests on the VNF
  61
  62           A VNF test case is successfull when the 3 steps are PASS
  63           If one of the step is FAIL, the test case is FAIL
  64
  65           Returns:
  66             TestCase.EX_OK if result is 'PASS'.
  67             TestCase.EX_TESTCASE_FAILED otherwise.
  68         """
  69         self.start_time = time.time()
  70
  71         try:
  72             self.prepare()
  73             if (self.deploy_orchestrator() and
  74                     self.deploy_vnf() and
  75                     self.test_vnf()):
  76                 self.stop_time = time.time()
  77                 # Calculation with different weight depending on the steps TODO
  78                 self.result = 100
  79                 return base.TestCase.EX_OK
  80             else:
  81                 self.result = 0
  82                 self.stop_time = time.time()
  83                 return base.TestCase.EX_TESTCASE_FAILED
  84         except Exception:  # pylint: disable=broad-except
  85             self.stop_time = time.time()
  86             self.__logger.exception("Exception on VNF testing")
  87             return base.TestCase.EX_TESTCASE_FAILED
  88
  89     def prepare(self):
  90         """
  91         Prepare the environment for VNF testing:
  92
  93             * Creation of a user,
  94             * Creation of a tenant,
  95             * Allocation admin role to the user on this tenant
  96
  97         Returns base.TestCase.EX_OK if preparation is successfull
  98
  99         Raise VnfPreparationException in case of problem
 100         """
 101         try:
 102             tenant_description = CONST.__getattribute__(
 103                 'vnf_{}_tenant_description'.format(self.case_name))
 104             self.__logger.info("Prepare VNF: %s, description: %s",
 105                                self.tenant_name, tenant_description)
 106             snaps_creds = openstack_tests.get_credentials(
 107                 os_env_file=CONST.__getattribute__('openstack_creds'))
 108
 109             project_creator = OpenStackProject(
 110                 snaps_creds,
 111                 ProjectSettings(
 112                     name=self.tenant_name,
 113                     description=tenant_description
 114                 ))
 115             project_creator.create()
 116             self.created_object.append(project_creator)
 117             self.os_project = project_creator
 118
 119             user_creator = OpenStackUser(snaps_creds,
 120                                          UserSettings(
 121                                              name=self.tenant_name,
 122                                              password=self.tenant_name))
 123             self.created_object.append(user_creator)
 124
 125             project_creator.assoc_user(user_creator.create())
 126
 127             self.snaps_creds = user_creator.get_os_creds(self.tenant_name)
 128
 129             return base.TestCase.EX_OK
 130         except Exception:  # pylint: disable=broad-except
 131             self.__logger.exception("Exception raised during VNF preparation")
 132             raise VnfPreparationException
 133
 134     def deploy_orchestrator(self):
 135         """
 136         Deploy an orchestrator (optional).
 137
 138         If function overwritten
 139         raise orchestratorDeploymentException if error during orchestrator
 140         deployment
 141         """
 142         self.__logger.info("Deploy orchestrator (if necessary)")
 143         return True
 144
 145     def deploy_vnf(self):
 146         """
 147         Deploy the VNF
 148
 149         This function MUST be implemented by vnf test cases.
 150         The details section MAY be updated in the vnf test cases.
 151
 152         The deployment can be executed via a specific orchestrator
 153         or using nuild-in orchestrators such as:
 154
 155             * heat, openbaton, cloudify (available on all scenario),
 156             * open-o (on open-o scenarios)
 157
 158         Returns:
 159             True if the VNF is properly deployed
 160             False if the VNF is not deployed
 161
 162         Raise VnfDeploymentException if error during VNF deployment
 163         """
 164         self.__logger.error("VNF must be deployed")
 165         raise VnfDeploymentException
 166
 167     def test_vnf(self):
 168         """
 169         Test the VNF
 170
 171         This function MUST be implemented by vnf test cases.
 172         The details section MAY be updated in the vnf test cases.
 173
 174         Once a VNF is deployed, it is assumed that specific test suite can be
 175         run to validate the VNF.
 176         Please note that the same test suite can be used on several test case
 177         (e.g. clearwater test suite can be used whatever the orchestrator used
 178         for the deployment)
 179
 180         Returns:
 181             True if VNF tests are PASS
 182             False if test suite is FAIL
 183
 184         Raise VnfTestException if error during VNF test
 185         """
 186         self.__logger.error("VNF must be tested")
 187         raise VnfTestException
 188
 189     def clean(self):
 190         """
 191         Clean VNF test case.
 192
 193         It is up to the test providers to delete resources used for the tests.
 194         By default we clean:
 195
 196             * the user,
 197             * the tenant
 198         """
 199         self.__logger.info("test cleaning")
 200         self.__logger.info('Remove the cloudify manager OS object ..')
 201         for creator in reversed(self.created_object):
 202             try:
 203                 creator.clean()
 204             except Exception as exc:  # pylint: disable=broad-except
 205                 self.__logger.error('Unexpected error cleaning - %s', exc)