import json
import logging
import os
-import pkg_resources
import uuid
from flask import jsonify
from flasgger.utils import swag_from
+import pkg_resources
from functest.api.base import ApiResource
from functest.api.common import api_utils
from functest.api.database.v1.handlers import TasksHandler
-from functest.utils.constants import CONST
+from functest.utils import config
LOGGER = logging.getLogger(__name__)
except ValueError:
return api_utils.result_handler(status=1, data='No such task id')
- task_log_dir = getattr(CONST, 'dir_results')
+ task_log_dir = getattr(config.CONF, 'dir_results')
# pylint: disable=maybe-no-member
index = int(self._get_args().get('index', 0))
from functest.api.common import api_utils, thread
from functest.cli.commands.cli_testcase import Testcase
from functest.api.database.v1.handlers import TasksHandler
-from functest.utils.constants import CONST
+from functest.utils import config
from functest.utils import env
import functest.utils.functest_utils as ft_utils
def _update_logging_ini(self, task_id): # pylint: disable=no-self-use
""" Update the log file for each task"""
- config = ConfigParser.RawConfigParser()
- config.read(
+ rconfig = ConfigParser.RawConfigParser()
+ rconfig.read(
pkg_resources.resource_filename('functest', 'ci/logging.ini'))
- log_path = os.path.join(getattr(CONST, 'dir_results'),
+ log_path = os.path.join(getattr(config.CONF, 'dir_results'),
'{}.log'.format(task_id))
- config.set('handler_file', 'args', '("{}",)'.format(log_path))
+ rconfig.set('handler_file', 'args', '("{}",)'.format(log_path))
with open(
pkg_resources.resource_filename(
'functest', 'ci/logging.ini'), 'wb') as configfile:
- config.write(configfile)
+ rconfig.write(configfile)
from functest.energy import energy
from functest.opnfv_tests.openstack.snaps import snaps_utils
from functest.opnfv_tests.openstack.tempest import conf_utils
-from functest.utils.constants import CONST
+from functest.utils import config
from functest.utils import env
from snaps.config.flavor import FlavorConfig
# pylint: disable=too-many-instance-attributes
TESTS = ['authenticate', 'glance', 'ceilometer', 'cinder', 'heat',
'keystone', 'neutron', 'nova', 'quotas', 'vm', 'all']
- GLANCE_IMAGE_NAME = getattr(CONST, 'openstack_image_name')
- GLANCE_IMAGE_FILENAME = getattr(CONST, 'openstack_image_file_name')
- GLANCE_IMAGE_PATH = os.path.join(getattr(CONST, 'dir_functest_images'),
- GLANCE_IMAGE_FILENAME)
- GLANCE_IMAGE_FORMAT = getattr(CONST, 'openstack_image_disk_format')
- GLANCE_IMAGE_USERNAME = getattr(CONST, 'openstack_image_username')
- GLANCE_IMAGE_EXTRA_PROPERTIES = getattr(CONST,
- 'openstack_extra_properties', {})
- FLAVOR_NAME = getattr(CONST, 'rally_flavor_name')
- FLAVOR_ALT_NAME = getattr(CONST, 'rally_flavor_alt_name')
+ GLANCE_IMAGE_NAME = getattr(config.CONF, 'openstack_image_name')
+ GLANCE_IMAGE_FILENAME = getattr(config.CONF, 'openstack_image_file_name')
+ GLANCE_IMAGE_PATH = os.path.join(getattr(
+ config.CONF, 'dir_functest_images'), GLANCE_IMAGE_FILENAME)
+ GLANCE_IMAGE_FORMAT = getattr(config.CONF, 'openstack_image_disk_format')
+ GLANCE_IMAGE_USERNAME = getattr(config.CONF, 'openstack_image_username')
+ GLANCE_IMAGE_EXTRA_PROPERTIES = getattr(
+ config.CONF, 'openstack_extra_properties', {})
+ FLAVOR_NAME = getattr(config.CONF, 'rally_flavor_name')
+ FLAVOR_ALT_NAME = getattr(config.CONF, 'rally_flavor_alt_name')
FLAVOR_RAM = 512
FLAVOR_RAM_ALT = 1024
- FLAVOR_EXTRA_SPECS = getattr(CONST, 'flavor_extra_specs', None)
+ FLAVOR_EXTRA_SPECS = getattr(config.CONF, 'flavor_extra_specs', None)
if FLAVOR_EXTRA_SPECS:
FLAVOR_RAM = 1024
FLAVOR_RAM_ALT = 2048
TENANTS_AMOUNT = 3
ITERATIONS_AMOUNT = 10
CONCURRENCY = 4
- RESULTS_DIR = os.path.join(getattr(CONST, 'dir_results'), 'rally')
+ RESULTS_DIR = os.path.join(getattr(config.CONF, 'dir_results'), 'rally')
BLACKLIST_FILE = os.path.join(RALLY_DIR, "blacklist.txt")
TEMP_DIR = os.path.join(RALLY_DIR, "var")
- RALLY_PRIVATE_NET_NAME = getattr(CONST, 'rally_network_name')
- RALLY_PRIVATE_SUBNET_NAME = getattr(CONST, 'rally_subnet_name')
- RALLY_PRIVATE_SUBNET_CIDR = getattr(CONST, 'rally_subnet_cidr')
- RALLY_ROUTER_NAME = getattr(CONST, 'rally_router_name')
+ RALLY_PRIVATE_NET_NAME = getattr(config.CONF, 'rally_network_name')
+ RALLY_PRIVATE_SUBNET_NAME = getattr(config.CONF, 'rally_subnet_name')
+ RALLY_PRIVATE_SUBNET_CIDR = getattr(config.CONF, 'rally_subnet_cidr')
+ RALLY_ROUTER_NAME = getattr(config.CONF, 'rally_router_name')
def __init__(self, **kwargs):
"""Initialize RallyBase object."""
LOGGER.debug("Creating network '%s'...", network_name)
- rally_network_type = getattr(CONST, 'rally_network_type', None)
- rally_physical_network = getattr(CONST, 'rally_physical_network', None)
- rally_segmentation_id = getattr(CONST, 'rally_segmentation_id', None)
+ rally_network_type = getattr(config.CONF, 'rally_network_type', None)
+ rally_physical_network = getattr(
+ config.CONF, 'rally_physical_network', None)
+ rally_segmentation_id = getattr(
+ config.CONF, 'rally_segmentation_id', None)
network_creator = deploy_utils.create_network(
self.os_creds, NetworkConfig(
from functest.core import unit
from functest.opnfv_tests.openstack.snaps import snaps_utils
-from functest.utils.constants import CONST
+from functest.utils import config
from functest.utils import env
from snaps.openstack import create_flavor
self.ext_net_name = snaps_utils.get_ext_net_name(self.os_creds)
self.netconf_override = None
- if hasattr(CONST, 'snaps_network_config'):
- self.netconf_override = getattr(CONST, 'snaps_network_config')
+ if hasattr(config.CONF, 'snaps_network_config'):
+ self.netconf_override = getattr(
+ config.CONF, 'snaps_network_config')
self.use_fip = (
- getattr(CONST, 'snaps_use_floating_ips') == 'True')
+ getattr(config.CONF, 'snaps_use_floating_ips') == 'True')
self.use_keystone = (
- getattr(CONST, 'snaps_use_keystone') == 'True')
+ getattr(config.CONF, 'snaps_use_keystone') == 'True')
scenario = env.get('DEPLOY_SCENARIO')
self.flavor_metadata = None
self.logger.info("Using flavor metadata '%s'", self.flavor_metadata)
self.image_metadata = None
- if hasattr(CONST, 'snaps_images'):
- self.image_metadata = getattr(CONST, 'snaps_images')
+ if hasattr(config.CONF, 'snaps_images'):
+ self.image_metadata = getattr(config.CONF, 'snaps_images')
"""Some common utils wrapping snaps functions """
+from functest.utils import config
from functest.utils import constants
from functest.utils import env
:return: an instance of snaps OSCreds object
"""
creds_override = None
- if hasattr(constants.CONST, 'snaps_os_creds_override'):
- creds_override = getattr(constants.CONST, 'snaps_os_creds_override')
+ if hasattr(config.CONF, 'snaps_os_creds_override'):
+ creds_override = getattr(config.CONF, 'snaps_os_creds_override')
os_creds = openstack_tests.get_credentials(
os_env_file=constants.ENV_FILE, proxy_settings_str=proxy_settings_str,
ssh_proxy_cmd=ssh_proxy_cmd, overrides=creds_override)
import pkg_resources
import yaml
-from functest.utils.constants import CONST
+from functest.utils import config
from functest.utils import env
import functest.utils.functest_utils as ft_utils
RALLY_AARCH64_PATCH_PATH = pkg_resources.resource_filename(
'functest', 'ci/rally_aarch64_patch.conf')
GLANCE_IMAGE_PATH = os.path.join(
- getattr(CONST, 'dir_functest_images'),
- getattr(CONST, 'openstack_image_file_name'))
-TEMPEST_RESULTS_DIR = os.path.join(getattr(CONST, 'dir_results'), 'tempest')
+ getattr(config.CONF, 'dir_functest_images'),
+ getattr(config.CONF, 'openstack_image_file_name'))
+TEMPEST_RESULTS_DIR = os.path.join(
+ getattr(config.CONF, 'dir_results'), 'tempest')
TEMPEST_CUSTOM = pkg_resources.resource_filename(
'functest', 'opnfv_tests/openstack/tempest/custom_tests/test_list.txt')
TEMPEST_BLACKLIST = pkg_resources.resource_filename(
'opnfv_tests/openstack/tempest/custom_tests/defcore_req.txt')
TEMPEST_RAW_LIST = os.path.join(TEMPEST_RESULTS_DIR, 'test_raw_list.txt')
TEMPEST_LIST = os.path.join(TEMPEST_RESULTS_DIR, 'test_list.txt')
-REFSTACK_RESULTS_DIR = os.path.join(getattr(CONST, 'dir_results'), 'refstack')
+REFSTACK_RESULTS_DIR = os.path.join(
+ getattr(config.CONF, 'dir_results'), 'refstack')
TEMPEST_CONF_YAML = pkg_resources.resource_filename(
'functest', 'opnfv_tests/openstack/tempest/custom_tests/tempest_conf.yaml')
TEST_ACCOUNTS_FILE = pkg_resources.resource_filename(
cmd = "rally deployment destroy opnfv-rally"
ft_utils.execute_command(cmd, error_msg=(
"Deployment %s does not exist."
- % getattr(CONST, 'rally_deployment_name')),
- verbose=False)
+ % getattr(config.CONF, 'rally_deployment_name')), verbose=False)
cmd = ("rally deployment create --fromenv --name={0}"
- .format(getattr(CONST, 'rally_deployment_name')))
+ .format(getattr(config.CONF, 'rally_deployment_name')))
error_msg = "Problem while creating Rally deployment"
ft_utils.execute_command_raise(cmd, error_msg=error_msg)
"""Create new verifier"""
LOGGER.info("Create verifier from existing repo...")
cmd = ("rally verify delete-verifier --id '{0}' --force").format(
- getattr(CONST, 'tempest_verifier_name'))
+ getattr(config.CONF, 'tempest_verifier_name'))
ft_utils.execute_command(cmd, error_msg=(
"Verifier %s does not exist."
- % getattr(CONST, 'tempest_verifier_name')),
+ % getattr(config.CONF, 'tempest_verifier_name')),
verbose=False)
cmd = ("rally verify create-verifier --source {0} "
"--name {1} --type tempest --system-wide"
- .format(getattr(CONST, 'dir_repo_tempest'),
- getattr(CONST, 'tempest_verifier_name')))
+ .format(getattr(config.CONF, 'dir_repo_tempest'),
+ getattr(config.CONF, 'tempest_verifier_name')))
ft_utils.execute_command_raise(cmd,
error_msg='Problem while creating verifier')
create_rally_deployment()
create_verifier()
cmd = ("rally verify list-verifiers | awk '/" +
- getattr(CONST, 'tempest_verifier_name') +
+ getattr(config.CONF, 'tempest_verifier_name') +
"/ {print $2}'")
proc = subprocess.Popen(cmd, shell=True,
stdout=subprocess.PIPE,
Returns deployment id for active Rally deployment
"""
cmd = ("rally deployment list | awk '/" +
- getattr(CONST, 'rally_deployment_name') +
+ getattr(config.CONF, 'rally_deployment_name') +
"/ {print $2}'")
proc = subprocess.Popen(cmd, shell=True,
stdout=subprocess.PIPE,
if not verifier_id:
verifier_id = get_verifier_id()
- return os.path.join(getattr(CONST, 'dir_rally_inst'),
+ return os.path.join(getattr(config.CONF, 'dir_rally_inst'),
'verification',
'verifier-{}'.format(verifier_id),
'repo')
if not deployment_id:
deployment_id = get_verifier_deployment_id()
- return os.path.join(getattr(CONST, 'dir_rally_inst'),
+ return os.path.join(getattr(config.CONF, 'dir_rally_inst'),
'verification',
'verifier-{}'.format(verifier_id),
'for-deployment-{}'.format(deployment_id))
flavor_id)
LOGGER.debug("Updating selected tempest.conf parameters for defcore...")
- config = ConfigParser.RawConfigParser()
- config.read(conf_file)
- config.set('DEFAULT', 'log_file', '{}/tempest.log'.format(deployment_dir))
- config.set('oslo_concurrency', 'lock_path',
- '{}/lock_files'.format(deployment_dir))
+ rconfig = ConfigParser.RawConfigParser()
+ rconfig.read(conf_file)
+ rconfig.set('DEFAULT', 'log_file', '{}/tempest.log'.format(deployment_dir))
+ rconfig.set('oslo_concurrency', 'lock_path',
+ '{}/lock_files'.format(deployment_dir))
generate_test_accounts_file(tenant_id=tenant_id)
- config.set('auth', 'test_accounts_file', TEST_ACCOUNTS_FILE)
- config.set('scenario', 'img_dir', '{}'.format(deployment_dir))
- config.set('scenario', 'img_file', 'tempest-image')
- config.set('compute', 'image_ref', image_id)
- config.set('compute', 'image_ref_alt', image_id_alt)
- config.set('compute', 'flavor_ref', flavor_id)
- config.set('compute', 'flavor_ref_alt', flavor_id_alt)
+ rconfig.set('auth', 'test_accounts_file', TEST_ACCOUNTS_FILE)
+ rconfig.set('scenario', 'img_dir', '{}'.format(deployment_dir))
+ rconfig.set('scenario', 'img_file', 'tempest-image')
+ rconfig.set('compute', 'image_ref', image_id)
+ rconfig.set('compute', 'image_ref_alt', image_id_alt)
+ rconfig.set('compute', 'flavor_ref', flavor_id)
+ rconfig.set('compute', 'flavor_ref_alt', flavor_id_alt)
with open(conf_file, 'wb') as config_file:
- config.write(config_file)
+ rconfig.write(config_file)
confpath = pkg_resources.resource_filename(
'functest',
LOGGER.debug("Add needed params into test_accounts.yaml...")
accounts_list = [
{
- 'tenant_name': getattr(CONST, 'tempest_identity_tenant_name'),
+ 'tenant_name': getattr(
+ config.CONF, 'tempest_identity_tenant_name'),
'tenant_id': str(tenant_id),
- 'username': getattr(CONST, 'tempest_identity_user_name'),
- 'password': getattr(CONST, 'tempest_identity_user_password')
+ 'username': getattr(config.CONF, 'tempest_identity_user_name'),
+ 'password': getattr(config.CONF, 'tempest_identity_user_password')
}
]
yaml.dump(accounts_list, tfile, default_flow_style=False)
-def update_tempest_conf_file(conf_file, config):
+def update_tempest_conf_file(conf_file, rconfig):
"""Update defined paramters into tempest config file"""
with open(TEMPEST_CONF_YAML) as yfile:
conf_yaml = yaml.safe_load(yfile)
if conf_yaml:
- sections = config.sections()
+ sections = rconfig.sections()
for section in conf_yaml:
if section not in sections:
- config.add_section(section)
+ rconfig.add_section(section)
sub_conf = conf_yaml.get(section)
for key, value in sub_conf.items():
- config.set(section, key, value)
+ rconfig.set(section, key, value)
with open(conf_file, 'wb') as config_file:
- config.write(config_file)
+ rconfig.write(config_file)
def configure_tempest_update_params(tempest_conf_file, network_name=None,
Add/update needed parameters into tempest.conf file
"""
LOGGER.debug("Updating selected tempest.conf parameters...")
- config = ConfigParser.RawConfigParser()
- config.read(tempest_conf_file)
- config.set('compute', 'fixed_network_name', network_name)
- config.set('compute', 'volume_device_name',
- getattr(CONST, 'tempest_volume_device_name'))
+ rconfig = ConfigParser.RawConfigParser()
+ rconfig.read(tempest_conf_file)
+ rconfig.set('compute', 'fixed_network_name', network_name)
+ rconfig.set('compute', 'volume_device_name',
+ getattr(config.CONF, 'tempest_volume_device_name'))
if image_id is not None:
- config.set('compute', 'image_ref', image_id)
+ rconfig.set('compute', 'image_ref', image_id)
if IMAGE_ID_ALT is not None:
- config.set('compute', 'image_ref_alt', IMAGE_ID_ALT)
- if getattr(CONST, 'tempest_use_custom_flavors'):
+ rconfig.set('compute', 'image_ref_alt', IMAGE_ID_ALT)
+ if getattr(config.CONF, 'tempest_use_custom_flavors'):
if flavor_id is not None:
- config.set('compute', 'flavor_ref', flavor_id)
+ rconfig.set('compute', 'flavor_ref', flavor_id)
if FLAVOR_ID_ALT is not None:
- config.set('compute', 'flavor_ref_alt', FLAVOR_ID_ALT)
+ rconfig.set('compute', 'flavor_ref_alt', FLAVOR_ID_ALT)
if compute_cnt > 1:
# enable multinode tests
- config.set('compute', 'min_compute_nodes', compute_cnt)
- config.set('compute-feature-enabled', 'live_migration', True)
+ rconfig.set('compute', 'min_compute_nodes', compute_cnt)
+ rconfig.set('compute-feature-enabled', 'live_migration', True)
- config.set('identity', 'region', os.environ.get('OS_REGION_NAME'))
+ rconfig.set('identity', 'region', os.environ.get('OS_REGION_NAME'))
identity_api_version = os.environ.get(
"OS_IDENTITY_API_VERSION", os.environ.get("IDENTITY_API_VERSION"))
if identity_api_version == '3':
auth_version = 'v3'
- config.set('identity-feature-enabled', 'api_v2', False)
+ rconfig.set('identity-feature-enabled', 'api_v2', False)
else:
auth_version = 'v2'
- config.set('identity', 'auth_version', auth_version)
- config.set(
+ rconfig.set('identity', 'auth_version', auth_version)
+ rconfig.set(
'validation', 'ssh_timeout',
- getattr(CONST, 'tempest_validation_ssh_timeout'))
- config.set('object-storage', 'operator_role',
- getattr(CONST, 'tempest_object_storage_operator_role'))
+ getattr(config.CONF, 'tempest_validation_ssh_timeout'))
+ rconfig.set('object-storage', 'operator_role',
+ getattr(config.CONF, 'tempest_object_storage_operator_role'))
if os.environ.get('OS_ENDPOINT_TYPE') is not None:
- config.set('identity', 'v3_endpoint_type',
- os.environ.get('OS_ENDPOINT_TYPE'))
+ rconfig.set('identity', 'v3_endpoint_type',
+ os.environ.get('OS_ENDPOINT_TYPE'))
if os.environ.get('OS_ENDPOINT_TYPE') is not None:
- sections = config.sections()
+ sections = rconfig.sections()
services_list = ['compute',
'volume',
'image',
'orchestration']
for service in services_list:
if service not in sections:
- config.add_section(service)
- config.set(service, 'endpoint_type',
- os.environ.get('OS_ENDPOINT_TYPE'))
+ rconfig.add_section(service)
+ rconfig.set(service, 'endpoint_type',
+ os.environ.get('OS_ENDPOINT_TYPE'))
LOGGER.debug('Add/Update required params defined in tempest_conf.yaml '
'into tempest.conf file')
- update_tempest_conf_file(tempest_conf_file, config)
+ update_tempest_conf_file(tempest_conf_file, rconfig)
backup_tempest_config(tempest_conf_file)
from functest.core import testcase
from functest.opnfv_tests.openstack.snaps import snaps_utils
from functest.opnfv_tests.openstack.tempest import conf_utils
-from functest.utils.constants import CONST
+from functest.utils import config
from functest.utils import env
import functest.utils.functest_utils as ft_utils
self.os_creds = kwargs.get('os_creds') or snaps_utils.get_credentials()
self.guid = '-' + str(uuid.uuid4())
self.creators = list()
- self.cirros_image_config = getattr(CONST, 'snaps_images_cirros', None)
+ self.cirros_image_config = getattr(
+ config.CONF, 'snaps_images_cirros', None)
def _create_project(self):
"""Create project for tests."""
project_creator = deploy_utils.create_project(
self.os_creds, ProjectConfig(
name=getattr(
- CONST, 'tempest_identity_tenant_name') + self.guid,
+ config.CONF, 'tempest_identity_tenant_name') + self.guid,
description=getattr(
- CONST, 'tempest_identity_tenant_description')))
+ config.CONF, 'tempest_identity_tenant_description')))
if project_creator is None or project_creator.get_project() is None:
raise Exception("Failed to create tenant")
self.creators.append(project_creator)
user_creator = deploy_utils.create_user(
self.os_creds, UserConfig(
name=getattr(
- CONST, 'tempest_identity_user_name') + self.guid,
+ config.CONF, 'tempest_identity_user_name') + self.guid,
password=getattr(
- CONST, 'tempest_identity_user_password'),
+ config.CONF, 'tempest_identity_user_password'),
project_name=getattr(
- CONST, 'tempest_identity_tenant_name') + self.guid))
+ config.CONF, 'tempest_identity_tenant_name') + self.guid))
if user_creator is None or user_creator.get_user() is None:
raise Exception("Failed to create user")
self.creators.append(user_creator)
tempest_segmentation_id = None
tempest_network_type = getattr(
- CONST, 'tempest_network_type', None)
+ config.CONF, 'tempest_network_type', None)
tempest_physical_network = getattr(
- CONST, 'tempest_physical_network', None)
+ config.CONF, 'tempest_physical_network', None)
tempest_segmentation_id = getattr(
- CONST, 'tempest_segmentation_id', None)
+ config.CONF, 'tempest_segmentation_id', None)
tempest_net_name = getattr(
- CONST, 'tempest_private_net_name') + self.guid
+ config.CONF, 'tempest_private_net_name') + self.guid
network_creator = deploy_utils.create_network(
self.os_creds, NetworkConfig(
segmentation_id=tempest_segmentation_id,
subnet_settings=[SubnetConfig(
name=getattr(
- CONST, 'tempest_private_subnet_name') + self.guid,
+ config.CONF,
+ 'tempest_private_subnet_name') + self.guid,
project_name=project_name,
cidr=getattr(
- CONST, 'tempest_private_subnet_cidr'))]))
+ config.CONF, 'tempest_private_subnet_cidr'))]))
if network_creator is None or network_creator.get_network() is None:
raise Exception("Failed to create private network")
self.creators.append(network_creator)
flavor_creator = OpenStackFlavor(
self.os_creds, FlavorConfig(
name=name,
- ram=getattr(CONST, 'openstack_flavor_ram'),
- disk=getattr(CONST, 'openstack_flavor_disk'),
- vcpus=getattr(CONST, 'openstack_flavor_vcpus'),
+ ram=getattr(config.CONF, 'openstack_flavor_ram'),
+ disk=getattr(config.CONF, 'openstack_flavor_disk'),
+ vcpus=getattr(config.CONF, 'openstack_flavor_vcpus'),
metadata=flavor_metadata))
flavor = flavor_creator.create()
if flavor is None:
if create_project:
LOGGER.debug("Creating project and user for Tempest suite")
project_name = getattr(
- CONST, 'tempest_identity_tenant_name') + self.guid
+ config.CONF, 'tempest_identity_tenant_name') + self.guid
result['project_id'] = self._create_project()
result['user_id'] = self._create_user()
result['tenant_id'] = result['project_id'] # for compatibility
result['tempest_net_name'] = self._create_network(project_name)
LOGGER.debug("Creating image for Tempest suite")
- image_name = getattr(CONST, 'openstack_image_name') + self.guid
+ image_name = getattr(config.CONF, 'openstack_image_name') + self.guid
result['image_id'] = self._create_image(image_name)
if use_custom_images:
LOGGER.debug("Creating 2nd image for Tempest suite")
- image_name = getattr(CONST, 'openstack_image_name_alt') + self.guid
+ image_name = getattr(
+ config.CONF, 'openstack_image_name_alt') + self.guid
result['image_id_alt'] = self._create_image(image_name)
- if (getattr(CONST, 'tempest_use_custom_flavors') == 'True' or
+ if (getattr(config.CONF, 'tempest_use_custom_flavors') == 'True' or
use_custom_flavors):
LOGGER.info("Creating flavor for Tempest suite")
- name = getattr(CONST, 'openstack_flavor_name') + self.guid
+ name = getattr(config.CONF, 'openstack_flavor_name') + self.guid
result['flavor_id'] = self._create_flavor(name)
if use_custom_flavors:
LOGGER.info("Creating 2nd flavor for Tempest suite")
scenario = env.get('DEPLOY_SCENARIO')
if 'ovs' in scenario or 'fdio' in scenario:
- setattr(CONST, 'openstack_flavor_ram', 1024)
- name = getattr(CONST, 'openstack_flavor_name_alt') + self.guid
+ setattr(config.CONF, 'openstack_flavor_ram', 1024)
+ name = getattr(
+ config.CONF, 'openstack_flavor_name_alt') + self.guid
result['flavor_id_alt'] = self._create_flavor(name)
return result
from functest.core import testcase
from functest.opnfv_tests.openstack.snaps import snaps_utils
-from functest.utils.constants import CONST
+from functest.utils import config
from functest.utils import env
from snaps.config.flavor import FlavorConfig
# Shared metadata
self.guid = '-' + str(uuid.uuid4())
- self.router_name = getattr(CONST, 'vping_router_name') + self.guid
- self.vm1_name = getattr(CONST, 'vping_vm_name_1') + self.guid
- self.vm2_name = getattr(CONST, 'vping_vm_name_2') + self.guid
+ self.router_name = getattr(
+ config.CONF, 'vping_router_name') + self.guid
+ self.vm1_name = getattr(
+ config.CONF, 'vping_vm_name_1') + self.guid
+ self.vm2_name = getattr(config.CONF, 'vping_vm_name_2') + self.guid
- self.vm_boot_timeout = getattr(CONST, 'vping_vm_boot_timeout')
- self.vm_delete_timeout = getattr(CONST, 'vping_vm_delete_timeout')
+ self.vm_boot_timeout = getattr(config.CONF, 'vping_vm_boot_timeout')
+ self.vm_delete_timeout = getattr(
+ config.CONF, 'vping_vm_delete_timeout')
self.vm_ssh_connect_timeout = getattr(
- CONST, 'vping_vm_ssh_connect_timeout')
- self.ping_timeout = getattr(CONST, 'vping_ping_timeout')
+ config.CONF, 'vping_vm_ssh_connect_timeout')
+ self.ping_timeout = getattr(config.CONF, 'vping_ping_timeout')
self.flavor_name = 'vping-flavor' + self.guid
# Move this configuration option up for all tests to leverage
- if hasattr(CONST, 'snaps_images_cirros'):
- self.cirros_image_config = getattr(CONST, 'snaps_images_cirros')
+ if hasattr(config.CONF, 'snaps_images_cirros'):
+ self.cirros_image_config = getattr(
+ config.CONF, 'snaps_images_cirros')
else:
self.cirros_image_config = None
'%Y-%m-%d %H:%M:%S'))
image_base_name = '{}-{}'.format(
- getattr(CONST, 'vping_image_name'),
+ getattr(config.CONF, 'vping_image_name'),
str(self.guid))
os_image_settings = openstack_tests.cirros_image_settings(
image_base_name, image_metadata=self.cirros_image_config)
self.os_creds, os_image_settings)
self.creators.append(self.image_creator)
- private_net_name = getattr(CONST, 'vping_private_net_name') + self.guid
+ private_net_name = getattr(
+ config.CONF, 'vping_private_net_name') + self.guid
private_subnet_name = getattr(
- CONST, 'vping_private_subnet_name') + self.guid
- private_subnet_cidr = getattr(CONST, 'vping_private_subnet_cidr')
+ config.CONF, 'vping_private_subnet_name') + self.guid
+ private_subnet_cidr = getattr(config.CONF, 'vping_private_subnet_cidr')
vping_network_type = None
vping_physical_network = None
vping_segmentation_id = None
- if hasattr(CONST, 'vping_network_type'):
- vping_network_type = getattr(CONST, 'vping_network_type')
- if hasattr(CONST, 'vping_physical_network'):
- vping_physical_network = getattr(CONST, 'vping_physical_network')
- if hasattr(CONST, 'vping_segmentation_id'):
- vping_segmentation_id = getattr(CONST, 'vping_segmentation_id')
+ if hasattr(config.CONF, 'vping_network_type'):
+ vping_network_type = getattr(config.CONF, 'vping_network_type')
+ if hasattr(config.CONF, 'vping_physical_network'):
+ vping_physical_network = getattr(
+ config.CONF, 'vping_physical_network')
+ if hasattr(config.CONF, 'vping_segmentation_id'):
+ vping_segmentation_id = getattr(
+ config.CONF, 'vping_segmentation_id')
self.logger.info(
"Creating network with name: '%s'", private_net_name)
Cleanup all OpenStack objects. Should be called on completion
:return:
"""
- if getattr(CONST, 'vping_cleanup_objects') == 'True':
+ if getattr(config.CONF, 'vping_cleanup_objects') == 'True':
for creator in reversed(self.creators):
try:
creator.clean()
from functest.core.testcase import TestCase
from functest.energy import energy
from functest.opnfv_tests.openstack.vping import vping_base
-from functest.utils.constants import CONST
+from functest.utils import config
from snaps.config.keypair import KeypairConfig
from snaps.config.network import PortConfig
kwargs["case_name"] = "vping_ssh"
super(VPingSSH, self).__init__(**kwargs)
- self.kp_name = getattr(CONST, 'vping_keypair_name') + self.guid
- self.kp_priv_file = getattr(CONST, 'vping_keypair_priv_file')
- self.kp_pub_file = getattr(CONST, 'vping_keypair_pub_file')
- self.sg_name = getattr(CONST, 'vping_sg_name') + self.guid
- self.sg_desc = getattr(CONST, 'vping_sg_desc')
+ self.kp_name = getattr(config.CONF, 'vping_keypair_name') + self.guid
+ self.kp_priv_file = getattr(config.CONF, 'vping_keypair_priv_file')
+ self.kp_pub_file = getattr(config.CONF, 'vping_keypair_pub_file')
+ self.sg_name = getattr(config.CONF, 'vping_sg_name') + self.guid
+ self.sg_desc = getattr(config.CONF, 'vping_sg_desc')
@energy.enable_recording
def run(self, **kwargs):
from functest.core import robotframework
from functest.opnfv_tests.openstack.snaps import snaps_utils
-from functest.utils import constants
+from functest.utils import config
from functest.utils import env
__author__ = "Cedric Ollivier <cedric.ollivier@orange.com>"
class ODLTests(robotframework.RobotFramework):
"""ODL test runner."""
- odl_test_repo = getattr(constants.CONST, 'dir_repo_odl_test')
+ odl_test_repo = getattr(config.CONF, 'dir_repo_odl_test')
neutron_suite_dir = os.path.join(
odl_test_repo, "csit/suites/openstack/neutron")
basic_suite_dir = os.path.join(
def __init__(self, **kwargs):
super(ODLTests, self).__init__(**kwargs)
self.res_dir = os.path.join(
- getattr(constants.CONST, 'dir_results'), 'odl')
+ getattr(config.CONF, 'dir_results'), 'odl')
self.xml_file = os.path.join(self.res_dir, 'output.xml')
@classmethod
from functest.core import vnf
from functest.opnfv_tests.openstack.snaps import snaps_utils
-from functest.utils.constants import CONST
+from functest.utils import config
from snaps.config.flavor import FlavorConfig
from snaps.config.image import ImageConfig
'functest', 'opnfv_tests/vnf/epc')
try:
self.config = getattr(
- CONST, 'vnf_{}_config'.format(self.case_name))
+ config.CONF, 'vnf_{}_config'.format(self.case_name))
except Exception:
raise Exception("VNF config file not found")
self.config_file = os.path.join(self.case_dir, self.config)
self.public_auth_url = None
self.res_dir = os.path.join(
- getattr(CONST, 'dir_results'), self.case_name)
+ getattr(config.CONF, 'dir_results'), self.case_name)
def _bypass_juju_network_discovery_bug(self, name):
user_creator = OpenStackUser(
"""
self.__logger.info("Deployed Orchestrator")
private_net_name = getattr(
- CONST, 'vnf_{}_private_net_name'.format(self.case_name))
+ config.CONF, 'vnf_{}_private_net_name'.format(self.case_name))
private_subnet_name = getattr(
- CONST, 'vnf_{}_private_subnet_name'.format(self.case_name))
+ config.CONF, 'vnf_{}_private_subnet_name'.format(self.case_name))
private_subnet_cidr = getattr(
- CONST, 'vnf_{}_private_subnet_cidr'.format(self.case_name))
+ config.CONF, 'vnf_{}_private_subnet_cidr'.format(self.case_name))
abot_router = getattr(
- CONST, 'vnf_{}_external_router'.format(self.case_name))
+ config.CONF, 'vnf_{}_external_router'.format(self.case_name))
self.__logger.info("Creating full network ...")
subnet_settings = SubnetConfig(
import requests
import functest.core.vnf as vnf
-from functest.utils.constants import CONST
+from functest.utils import config
import functest.utils.functest_utils as ft_utils
__author__ = ("Valentin Boucher <valentin.boucher@orange.com>, "
super(ClearwaterOnBoardingBase, self).__init__(**kwargs)
self.case_dir = pkg_resources.resource_filename(
'functest', 'opnfv_tests/vnf/ims')
- self.data_dir = getattr(CONST, 'dir_ims_data')
- self.result_dir = os.path.join(getattr(CONST, 'dir_results'),
+ 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(CONST, 'dir_repo_vims_test')
+ self.test_dir = getattr(config.CONF, 'dir_repo_vims_test')
if not os.path.exists(self.data_dir):
os.makedirs(self.data_dir)
from functest.energy import energy
from functest.opnfv_tests.openstack.snaps import snaps_utils
import functest.opnfv_tests.vnf.ims.clearwater_ims_base as clearwater_ims_base
-from functest.utils.constants import CONST
+from functest.utils import config
from snaps.config.flavor import FlavorConfig
from snaps.config.image import ImageConfig
# Retrieve the configuration
try:
self.config = getattr(
- CONST, 'vnf_{}_config'.format(self.case_name))
+ config.CONF, 'vnf_{}_config'.format(self.case_name))
except Exception:
raise Exception("VNF config file not found")
from functest.opnfv_tests.vnf.ims.ixia.utils import IxChassisUtils
from functest.opnfv_tests.vnf.ims.ixia.utils import IxLoadUtils
from functest.opnfv_tests.vnf.ims.ixia.utils import IxRestUtils
-from functest.utils.constants import CONST
+from functest.utils import config
from snaps.config.flavor import FlavorConfig
from snaps.config.image import ImageConfig
# Retrieve the configuration
try:
self.config = getattr(
- CONST, 'vnf_{}_config'.format(self.case_name))
+ config.CONF, 'vnf_{}_config'.format(self.case_name))
except Exception:
raise Exception("VNF config file not found")
import functest.core.vnf as vnf
import functest.utils.openstack_utils as os_utils
from functest.opnfv_tests.openstack.snaps import snaps_utils
-from functest.utils.constants import CONST
+from functest.utils import config
from org.openbaton.cli.errors.errors import NfvoException
from org.openbaton.cli.agents.agents import MainAgent
self.case_dir = pkg_resources.resource_filename(
'functest', 'opnfv_tests/vnf/ims/')
- self.data_dir = getattr(CONST, 'dir_ims_data')
- self.test_dir = getattr(CONST, 'dir_repo_vims_test')
+ self.data_dir = getattr(config.CONF, 'dir_ims_data')
+ self.test_dir = getattr(config.CONF, 'dir_repo_vims_test')
self.created_resources = []
self.logger.info("%s VNF onboarding test starting", self.case_name)
try:
self.config = getattr(
- CONST, 'vnf_{}_config'.format(self.case_name))
+ config.CONF, 'vnf_{}_config'.format(self.case_name))
except BaseException:
raise Exception("Orchestra VNF config file not found")
import functest.core.vnf as vnf
import functest.utils.openstack_utils as os_utils
-from functest.utils.constants import CONST
+from functest.utils import config
from org.openbaton.cli.errors.errors import NfvoException
from org.openbaton.cli.agents.agents import MainAgent
self.case_dir = pkg_resources.resource_filename(
'functest', 'opnfv_tests/vnf/ims/')
- self.data_dir = getattr(CONST, 'dir_ims_data')
- self.test_dir = getattr(CONST, 'dir_repo_vims_test')
+ self.data_dir = getattr(config.CONF, 'dir_ims_data')
+ self.test_dir = getattr(config.CONF, 'dir_repo_vims_test')
self.created_resources = []
self.logger.info("%s VNF onboarding test starting", self.case_name)
try:
self.config = getattr(
- CONST, 'vnf_{}_config'.format(self.case_name))
+ config.CONF, 'vnf_{}_config'.format(self.case_name))
except BaseException:
raise Exception("Orchestra VNF config file not found")
config_file = self.case_dir + self.config
self.logger.info("Additional pre-configuration steps")
self.creds = {
- "tenant": self.snaps_creds.project_name,
- "username": self.snaps_creds.username,
- "password": self.snaps_creds.password,
- "auth_url": public_auth_url
- }
+ "tenant": self.snaps_creds.project_name,
+ "username": self.snaps_creds.username,
+ "password": self.snaps_creds.password,
+ "auth_url": public_auth_url}
self.prepare_images()
self.prepare_flavor()
self.prepare_security_groups()
from functest.opnfv_tests.openstack.snaps import snaps_utils
import functest.opnfv_tests.vnf.router.vrouter_base as vrouter_base
from functest.opnfv_tests.vnf.router.utilvnf import Utilvnf
-from functest.utils.constants import CONST
+from functest.utils import config
from functest.utils import functest_utils
from git import Repo
# Retrieve the configuration
try:
self.config = getattr(
- CONST, 'vnf_{}_config'.format(self.case_name))
+ config.CONF, 'vnf_{}_config'.format(self.case_name))
except Exception:
raise Exception("VNF config file not found")
import requests
import yaml
-from functest.utils.constants import CONST
+from functest.utils import config
from git import Repo
from requests.auth import HTTPBasicAuth
from snaps.openstack.utils import nova_utils
def __init__(self):
self.snaps_creds = ""
- self.vnf_data_dir = getattr(CONST, 'dir_router_data')
+ self.vnf_data_dir = getattr(config.CONF, 'dir_router_data')
self.opnfv_vnf_data_dir = "opnfv-vnf-data/"
self.command_template_dir = "command_template/"
self.test_scenario_yaml = "test_scenario.yaml"
'functest', 'opnfv_tests/vnf/router')
config_file_name = getattr(
- CONST, 'vnf_{}_config'.format("vyos_vrouter"))
+ config.CONF, 'vnf_{}_config'.format("vyos_vrouter"))
config_file = os.path.join(case_dir, config_file_name)
import pkg_resources
import functest.core.vnf as vnf
-from functest.utils.constants import CONST
+from functest.utils import config
from functest.opnfv_tests.vnf.router.test_controller import function_test_exec
from functest.opnfv_tests.vnf.router.utilvnf import Utilvnf
super(VrouterOnBoardingBase, self).__init__(**kwargs)
self.case_dir = pkg_resources.resource_filename(
'functest', 'opnfv_tests/vnf/router')
- self.data_dir = getattr(CONST, 'dir_router_data')
- self.result_dir = os.path.join(getattr(CONST, 'dir_results'),
+ self.data_dir = getattr(config.CONF, 'dir_router_data')
+ self.result_dir = os.path.join(getattr(config.CONF, 'dir_results'),
self.case_name)
self.util = Utilvnf()
self.util_info = {}
import mock
from functest.opnfv_tests.openstack.tempest import tempest, conf_utils
-from functest.utils.constants import CONST
+from functest.utils import config
from snaps.openstack.os_credentials import OSCreds
tempest_resources = tempest.TempestResourcesManager(
os_creds=self.os_creds)
- setattr(CONST, 'tempest_use_custom_flavors', 'True')
+ setattr(config.CONF, 'tempest_use_custom_flavors', 'True')
with self.assertRaises(Exception) as context:
tempest_resources.create()
msg = 'Failed to create flavor'
self.assertTrue(msg in context.exception, msg=str(context.exception))
- setattr(CONST, 'tempest_use_custom_flavors', 'False')
+ setattr(config.CONF, 'tempest_use_custom_flavors', 'False')
with self.assertRaises(Exception) as context:
tempest_resources.create(use_custom_flavors=True)
msg = 'Failed to create flavor'
cmd = "rally deployment destroy opnfv-rally"
error_msg = "Deployment %s does not exist." % \
- getattr(CONST, 'rally_deployment_name')
+ getattr(config.CONF, 'rally_deployment_name')
mock_logger_info.assert_any_call("Creating Rally environment...")
mock_exec.assert_any_call(cmd, error_msg=error_msg, verbose=False)
cmd = "rally deployment create --fromenv --name="
- cmd += getattr(CONST, 'rally_deployment_name')
+ cmd += getattr(config.CONF, 'rally_deployment_name')
error_msg = "Problem while creating Rally deployment"
mock_exec_raise.assert_any_call(cmd, error_msg=error_msg)
'stdout.readline.return_value': '0'}
mock_popen.configure_mock(**attrs)
- setattr(CONST, 'tempest_verifier_name', 'test_veifier_name')
+ setattr(config.CONF, 'tempest_verifier_name', 'test_verifier_name')
with mock.patch('functest.utils.functest_utils.execute_command_raise',
side_effect=Exception), \
self.assertRaises(Exception):
conf_utils.create_verifier()
- mock_logger_debug.assert_any_call("Tempest test_veifier_name"
+ mock_logger_debug.assert_any_call("Tempest test_verifier_name"
" does not exist")
@mock.patch('functest.opnfv_tests.openstack.tempest.conf_utils.'
'create_rally_deployment', return_value=mock.Mock())
def test_get_verif_id_missing_verif(self, mock_rally, mock_tempest):
# pylint: disable=unused-argument
- setattr(CONST, 'tempest_verifier_name', 'test_verifier_name')
+ setattr(config.CONF, 'tempest_verifier_name', 'test_verifier_name')
with mock.patch('functest.opnfv_tests.openstack.tempest.'
'conf_utils.subprocess.Popen') as mock_popen, \
self.assertRaises(Exception):
'create_rally_deployment', return_value=mock.Mock())
def test_get_verifier_id_default(self, mock_rally, mock_tempest):
# pylint: disable=unused-argument
- setattr(CONST, 'tempest_verifier_name', 'test_verifier_name')
+ setattr(config.CONF, 'tempest_verifier_name', 'test_verifier_name')
with mock.patch('functest.opnfv_tests.openstack.tempest.'
'conf_utils.subprocess.Popen') as mock_popen:
mock_stdout = mock.Mock()
'test_deploy_id')
def test_get_depl_id_missing_rally(self):
- setattr(CONST, 'tempest_verifier_name', 'test_deploy_name')
+ setattr(config.CONF, 'tempest_verifier_name', 'test_deploy_name')
with mock.patch('functest.opnfv_tests.openstack.tempest.'
'conf_utils.subprocess.Popen') as mock_popen, \
self.assertRaises(Exception):
conf_utils.get_verifier_deployment_id()
def test_get_depl_id_default(self):
- setattr(CONST, 'tempest_verifier_name', 'test_deploy_name')
+ setattr(config.CONF, 'tempest_verifier_name', 'test_deploy_name')
with mock.patch('functest.opnfv_tests.openstack.tempest.'
'conf_utils.subprocess.Popen') as mock_popen:
mock_stdout = mock.Mock()
'test_image_id_alt'), None, None)
def test_upd_missing_flavor_id(self):
- setattr(CONST, 'tempest_use_custom_flavors', 'True')
+ setattr(config.CONF, 'tempest_use_custom_flavors', 'True')
self._test_missing_param(('compute', 'flavor_ref', 'test_flavor_id'),
None, 'test_flavor_id')
def test_upd_missing_flavor_id_alt(self):
- setattr(CONST, 'tempest_use_custom_flavors', 'True')
+ setattr(config.CONF, 'tempest_use_custom_flavors', 'True')
conf_utils.FLAVOR_ID_ALT = 'test_flavor_id_alt'
self._test_missing_param(('compute', 'flavor_ref_alt',
'test_flavor_id_alt'), None, None)
with mock.patch('functest.opnfv_tests.openstack.tempest.'
'conf_utils.os.path.isfile',
return_value=False), \
- mock.patch('functest.opnfv_tests.openstack.tempest.'
- 'conf_utils.ft_utils.execute_command') as mexe, \
+ mock.patch('functest.opnfv_tests.openstack.tempest.'
+ 'conf_utils.ft_utils.execute_command') as mexe, \
self.assertRaises(Exception) as context:
conf_utils.configure_verifier('test_dep_dir')
mexe.assert_any_call("rally verify configure-verifier")
msg = ("Tempest configuration file 'test_dep_dir/tempest.conf'"
" NOT found.")
- self.assertTrue(msg in context)
+ self.assertTrue(msg in context.exception)
def test_configure_verifier_default(self):
with mock.patch('functest.opnfv_tests.openstack.tempest.'
from six.moves import reload_module
from functest.utils import env
-from functest.utils import constants
class EnvTesting(unittest.TestCase):
def test_get_unset_unknown_env(self):
del os.environ['FOO']
self.assertEqual(env.get('FOO'), None)
- # Backward compatibilty (waiting for SDNVPN and SFC)
- reload_module(env)
- with self.assertRaises(AttributeError):
- getattr(env.ENV, 'FOO')
- reload_module(constants)
- with self.assertRaises(AttributeError):
- getattr(constants.CONST, 'FOO')
def test_get_unknown_env(self):
self.assertEqual(env.get('FOO'), 'foo')
reload_module(env)
- # Backward compatibilty (waiting for SDNVPN and SFC)
- with self.assertRaises(AttributeError):
- getattr(env.ENV, 'FOO')
- reload_module(constants)
- with self.assertRaises(AttributeError):
- getattr(constants.CONST, 'FOO')
def test_get_unset_env(self):
del os.environ['CI_LOOP']
self.assertEqual(
env.get('CI_LOOP'), env.INPUTS['CI_LOOP'])
- # Backward compatibilty (waiting for SDNVPN and SFC)
- reload_module(env)
- self.assertEqual(
- getattr(env.ENV, 'CI_LOOP'), env.INPUTS['CI_LOOP'])
- reload_module(constants)
- self.assertEqual(
- getattr(constants.CONST, 'CI_LOOP'),
- env.INPUTS['CI_LOOP'])
def test_get_env(self):
self.assertEqual(
env.get('CI_LOOP'), 'weekly')
- # Backward compatibilty (waiting for SDNVPN and SFC)
- reload_module(env)
- self.assertEqual(getattr(env.ENV, 'CI_LOOP'), 'weekly')
- reload_module(constants)
- self.assertEqual(getattr(constants.CONST, 'CI_LOOP'), 'weekly')
def test_get_unset_env2(self):
del os.environ['BUILD_TAG']
self.assertEqual(
env.get('BUILD_TAG'), env.INPUTS['BUILD_TAG'])
- # Backward compatibilty (waiting for SDNVPN and SFC)
- reload_module(env)
- self.assertEqual(
- getattr(env.ENV, 'BUILD_TAG'), env.INPUTS['BUILD_TAG'])
- reload_module(constants)
- self.assertEqual(
- getattr(constants.CONST, 'BUILD_TAG'), env.INPUTS['BUILD_TAG'])
def test_get_env2(self):
self.assertEqual(env.get('BUILD_TAG'), 'master')
- # Backward compatibilty (waiting for SDNVPN and SFC)
- reload_module(env)
- self.assertEqual(getattr(env.ENV, 'BUILD_TAG'), 'master')
- reload_module(env)
- self.assertEqual(getattr(constants.CONST, 'BUILD_TAG'), 'master')
if __name__ == "__main__":
# pylint: disable=missing-docstring
import pkg_resources
-import six
-
-from functest.utils import config
-from functest.utils import env
CONFIG_FUNCTEST_YAML = pkg_resources.resource_filename(
'functest', 'ci/config_functest.yaml')
ENV_FILE = '/home/opnfv/functest/conf/env_file'
-
-
-class Constants(object): # pylint: disable=too-few-public-methods
-
- # Backward compatibility (waiting for SDNVPN and SFC)
- CONFIG_FUNCTEST_YAML = CONFIG_FUNCTEST_YAML
- env_file = ENV_FILE
-
- def __init__(self):
- for attr_n, attr_v in six.iteritems(config.CONF.__dict__):
- setattr(self, attr_n, attr_v)
- for env_n, env_v in six.iteritems(env.ENV.__dict__):
- setattr(self, env_n, env_v)
-
-
-CONST = Constants()
import os
-import six
-
INPUTS = {
'EXTERNAL_NETWORK': None,
'CI_LOOP': 'daily',
if env_var not in INPUTS.keys():
return os.environ.get(env_var, None)
return os.environ.get(env_var, INPUTS[env_var])
-
-
-class Environment(object): # pylint: disable=too-few-public-methods
-
- # Backward compatibility (waiting for SDNVPN and SFC)
- def __init__(self):
- for key, _ in six.iteritems(INPUTS):
- setattr(self, key, get(key))
-
-# Backward compatibility (waiting for SDNVPN and SFC)
-ENV = Environment()
def get_functest_config(parameter):
- yaml_ = constants.Constants.CONFIG_FUNCTEST_YAML
+ yaml_ = constants.CONFIG_FUNCTEST_YAML
return get_parameter_from_yaml(parameter, yaml_)
def get_functest_yaml():
# pylint: disable=bad-continuation
- with open(constants.Constants.CONFIG_FUNCTEST_YAML) as yaml_fd:
+ with open(constants.CONFIG_FUNCTEST_YAML) as yaml_fd:
functest_yaml = yaml.safe_load(yaml_fd)
return functest_yaml
Code Review / functest-xtesting.git / commitdiff