# $ docker run -t -i \
# -e "INSTALLER_TYPE=fuel|apex|compass|joid \
# -e "INSTALLER_IP=10.20.0.2" \
-# -v $(pwd)/config_functest.yaml:/home/opnfv/repos/functest/ci/config_functest.yaml
+# -v $(pwd)/config_functest.yaml:/home/opnfv/repos/functest/functest/ci/config_functest.yaml
# opnfv/functest /bin/bash
#
# NOTE: providing config_functest.yaml is optional. If not provided, it will
MAINTAINER Jose Lausuch <jose.lausuch@ericsson.com>
LABEL version="0.1" description="OPNFV Functest Docker container"
+# Environment variables
ARG BRANCH=master
ARG TEMPEST_TAG=12.2.0
ARG RALLY_TAG=0.7.0
ARG OPENSTACK_TAG=stable/mitaka
ARG KINGBIRD_TAG=0.2.2
ARG VIMS_TAG=stable
+ARG REPOS_DIR=/home/opnfv/repos
+ARG FUNCTEST_BASE_DIR=/home/opnfv/functest
+ARG FUNCTEST_CONF_DIR=${FUNCTEST_BASE_DIR}/conf
+ARG FUNCTEST_DATA_DIR=${FUNCTEST_BASE_DIR}/data
+ARG FUNCTEST_RESULTS_DIR=${FUNCTEST_BASE_DIR}/results
+ARG FUNCTEST_REPO_DIR=${REPOS_DIR}/functest
+ARG FUNCTEST_TEST_DIR=${FUNCTEST_REPO_DIR}/functest/opnfv_tests
+
+# Environment variables
ENV HOME /home/opnfv
-ENV repos_dir /home/opnfv/repos
-ENV creds /home/opnfv/functest/conf/openstack.creds
+ENV CONFIG_FUNCTEST_YAML ${FUNCTEST_REPO_DIR}/functest/ci/config_functest.yaml
+ENV REPOS_DIR ${HOME}/repos
+ENV creds ${FUNCTEST_CONF_DIR}/openstack.creds
ENV TERM xterm
ENV COLORTERM gnome-terminal
-ENV CONFIG_FUNCTEST_YAML /home/opnfv/repos/functest/functest/ci/config_functest.yaml
-WORKDIR /home/opnfv
+
+
+WORKDIR ${HOME}
# Packaged dependencies
RUN apt-get update && apt-get install -y \
libxml2-dev \
libffi-dev \
crudini \
-ruby-dev \
+ruby1.9.1-dev \
--no-install-recommends
RUN pip install --upgrade pip
-RUN mkdir -p ${repos_dir}
-RUN mkdir -p /home/opnfv/functest/results
-RUN mkdir -p /home/opnfv/functest/conf
+RUN mkdir -p ${REPOS_DIR}
+RUN mkdir -p ${FUNCTEST_BASE_DIR}/results
+RUN mkdir -p ${FUNCTEST_BASE_DIR}/conf
RUN mkdir -p /root/.ssh
RUN chmod 700 /root/.ssh
RUN git config --global http.sslVerify false
# OPNFV repositories
-RUN git clone --depth 1 -b $BRANCH https://gerrit.opnfv.org/gerrit/functest ${repos_dir}/functest
-RUN git clone --depth 1 -b $BRANCH https://gerrit.opnfv.org/gerrit/copper ${repos_dir}/copper
-RUN git clone --depth 1 -b $BRANCH https://gerrit.opnfv.org/gerrit/moon ${repos_dir}/moon
-RUN git clone --depth 1 -b $BRANCH https://gerrit.opnfv.org/gerrit/sdnvpn ${repos_dir}/sdnvpn
-RUN git clone --depth 1 -b $BRANCH https://gerrit.opnfv.org/gerrit/domino ${repos_dir}/domino
-RUN git clone --depth 1 -b $BRANCH https://gerrit.opnfv.org/gerrit/parser ${repos_dir}/parser
-RUN git clone --depth 1 -b $BRANCH https://gerrit.opnfv.org/gerrit/doctor ${repos_dir}/doctor
-RUN git clone --depth 1 -b $BRANCH https://gerrit.opnfv.org/gerrit/ovno ${repos_dir}/ovno
-RUN git clone --depth 1 -b $BRANCH https://gerrit.opnfv.org/gerrit/promise ${repos_dir}/promise
-RUN git clone --depth 1 -b $BRANCH https://gerrit.opnfv.org/gerrit/sfc ${repos_dir}/sfc
-RUN git clone --depth 1 https://gerrit.opnfv.org/gerrit/securityscanning ${repos_dir}/securityscanning
-RUN git clone --depth 1 https://gerrit.opnfv.org/gerrit/releng ${repos_dir}/releng
-
+RUN git clone --depth 1 -b $BRANCH https://gerrit.opnfv.org/gerrit/functest ${REPOS_DIR}/functest
+RUN git clone --depth 1 -b $BRANCH https://gerrit.opnfv.org/gerrit/copper ${REPOS_DIR}/copper
+RUN git clone --depth 1 -b $BRANCH https://gerrit.opnfv.org/gerrit/moon ${REPOS_DIR}/moon
+RUN git clone --depth 1 -b $BRANCH https://gerrit.opnfv.org/gerrit/sdnvpn ${REPOS_DIR}/sdnvpn
+RUN git clone --depth 1 -b $BRANCH https://gerrit.opnfv.org/gerrit/domino ${REPOS_DIR}/domino
+RUN git clone --depth 1 -b $BRANCH https://gerrit.opnfv.org/gerrit/parser ${REPOS_DIR}/parser
+RUN git clone --depth 1 -b $BRANCH https://gerrit.opnfv.org/gerrit/doctor ${REPOS_DIR}/doctor
+RUN git clone --depth 1 -b $BRANCH https://gerrit.opnfv.org/gerrit/ovno ${REPOS_DIR}/ovno
+RUN git clone --depth 1 -b $BRANCH https://gerrit.opnfv.org/gerrit/promise ${REPOS_DIR}/promise
+RUN git clone --depth 1 -b $BRANCH https://gerrit.opnfv.org/gerrit/sfc ${REPOS_DIR}/sfc
+RUN git clone --depth 1 https://gerrit.opnfv.org/gerrit/securityscanning ${REPOS_DIR}/securityscanning
+RUN git clone --depth 1 https://gerrit.opnfv.org/gerrit/releng ${REPOS_DIR}/releng
# OpenStack repositories
-RUN git clone --depth 1 -b $OPENSTACK_TAG https://github.com/openstack/networking-bgpvpn ${repos_dir}/bgpvpn
-RUN git clone --depth 1 -b $KINGBIRD_TAG https://github.com/openstack/kingbird.git ${repos_dir}/kingbird
-RUN git clone --depth 1 -b $RALLY_TAG https://github.com/openstack/rally.git ${repos_dir}/rally
-RUN git clone --depth 1 -b $TEMPEST_TAG https://github.com/openstack/tempest.git ${repos_dir}/tempest
+RUN git clone --depth 1 -b $OPENSTACK_TAG https://github.com/openstack/networking-bgpvpn ${REPOS_DIR}/bgpvpn
+#RUN git clone --depth 1 -b $KINGBIRD_TAG https://github.com/openstack/kingbird.git ${REPOS_DIR}/kingbird
+RUN git clone --depth 1 -b $RALLY_TAG https://github.com/openstack/rally.git ${REPOS_DIR}/rally
+RUN git clone --depth 1 -b $TEMPEST_TAG https://github.com/openstack/tempest.git ${REPOS_DIR}/tempest
# other repositories
-RUN git clone --depth 1 -b $ODL_TAG https://git.opendaylight.org/gerrit/p/integration/test.git ${repos_dir}/odl_test
-RUN git clone --depth 1 -b $VIMS_TAG https://github.com/boucherv-orange/clearwater-live-test ${repos_dir}/vims-test
-RUN git clone --depth 1 https://github.com/wuwenbin2/OnosSystemTest.git ${repos_dir}/onos
+RUN git clone --depth 1 -b $ODL_TAG https://git.opendaylight.org/gerrit/p/integration/test.git ${REPOS_DIR}/odl_test
+RUN git clone --depth 1 -b $VIMS_TAG https://github.com/boucherv-orange/clearwater-live-test ${REPOS_DIR}/vims-test
+RUN git clone --depth 1 https://github.com/wuwenbin2/OnosSystemTest.git ${REPOS_DIR}/onos
-RUN pip install -r ${repos_dir}/functest/docker/requirements.pip
-RUN cd ${repos_dir}/functest && pip install .
-RUN pip install -r ${repos_dir}/rally/requirements.txt
-RUN pip install -r ${repos_dir}/tempest/requirements.txt
+RUN pip install -r ${FUNCTEST_REPO_DIR}/docker/requirements.pip
+RUN cd ${FUNCTEST_REPO_DIR} && pip install .
+RUN pip install -r ${REPOS_DIR}/rally/requirements.txt
+RUN pip install -r ${REPOS_DIR}/tempest/requirements.txt
-RUN find ${repos_dir}/functest -name "*.py" \
+RUN find ${FUNCTEST_REPO_DIR} -name "*.py" \
-not -path *unit_tests* |xargs grep __main__ |cut -d\: -f 1 |xargs chmod -c 755
-RUN find ${repos_dir}/functest -name "*.sh" |xargs grep \#\! |cut -d\: -f 1 |xargs chmod -c 755
+RUN find ${FUNCTEST_REPO_DIR} -name "*.sh" |xargs grep \#\! |cut -d\: -f 1 |xargs chmod -c 755
-RUN /bin/bash ${repos_dir}/parser/tests/parser_install.sh ${repos_dir}
-RUN ${repos_dir}/rally/install_rally.sh --yes
+RUN /bin/bash ${REPOS_DIR}/parser/tests/parser_install.sh ${REPOS_DIR}
+RUN ${REPOS_DIR}/rally/install_rally.sh --yes
-ADD http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-disk.img /home/opnfv/functest/data/
-ADD http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-lxc.tar.gz /home/opnfv/functest/data/
-ADD http://205.177.226.237:9999/onosfw/firewall_block_image.img /home/opnfv/functest/data/
+ADD http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-disk.img ${FUNCTEST_BASE_DIR}/data/
+ADD http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-lxc.tar.gz ${FUNCTEST_BASE_DIR}/data/
+ADD http://205.177.226.237:9999/onosfw/firewall_block_image.img ${FUNCTEST_BASE_DIR}/data/
RUN gpg --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3
RUN curl -L https://get.rvm.io | bash -s stable
# SNAPS integration
-RUN git clone --depth 1 https://gerrit.cablelabs.com/snaps-provisioning ${repos_dir}/snaps
-RUN pip install -e ${repos_dir}/snaps/
+RUN git clone --depth 1 https://gerrit.cablelabs.com/snaps-provisioning ${REPOS_DIR}/snaps
+RUN pip install -e ${REPOS_DIR}/snaps/
-RUN /bin/bash -c ". /home/opnfv/repos/sfc/tests/functest/odl-sfc/tacker_client_install.sh"
-RUN cd ${repos_dir}/bgpvpn && pip install .
-#RUN cd ${repos_dir}/kingbird && pip install -e .
-RUN cd ${repos_dir}/moon/moonclient/ && python setup.py install
+RUN /bin/bash -c ". ${REPOS_DIR}/sfc/tests/functest/odl-sfc/tacker_client_install.sh"
+RUN cd ${REPOS_DIR}/bgpvpn && pip install .
+#RUN cd ${REPOS_DIR}/kingbird && pip install -e .
+RUN cd ${REPOS_DIR}/moon/moonclient/ && python setup.py install
RUN /bin/bash -c ". /etc/profile.d/rvm.sh \
- && cd /home/opnfv/repos/vims-test \
+ && cd ${REPOS_DIR}/vims-test \
&& rvm autolibs enable"
RUN /bin/bash -c ". /etc/profile.d/rvm.sh \
- && cd /home/opnfv/repos/vims-test \
+ && cd ${REPOS_DIR}/vims-test \
&& rvm install 1.9.3"
RUN /bin/bash -c ". /etc/profile.d/rvm.sh \
- && cd /home/opnfv/repos/vims-test \
+ && cd ${REPOS_DIR}/vims-test \
&& rvm use 1.9.3"
RUN /bin/bash -c ". /etc/profile.d/rvm.sh \
- && cd /home/opnfv/repos/vims-test \
+ && cd ${REPOS_DIR}/vims-test \
&& bundle install"
RUN sh -c 'curl -sL https://deb.nodesource.com/setup_4.x | sudo -E bash -'
RUN sudo apt-get install -y nodejs
-RUN cd ${repos_dir}/promise && sudo npm -g install npm@latest
-RUN cd ${repos_dir}/promise/source && npm install
+RUN cd ${REPOS_DIR}/promise && sudo npm -g install npm@latest
+RUN cd ${REPOS_DIR}/promise/source && npm install
RUN echo "set nocompatible \n\
set backspace=2" \
->> /home/opnfv/.vimrc
-RUN echo set nocompatible >> /home/opnfv/.exrc
+>> ${HOME}/.vimrc
+RUN echo set nocompatible >> ${HOME}/.exrc
RUN echo "alias ll='ls -lh' \n\
-. /home/opnfv/repos/functest/functest/cli/functest-complete.sh" \
->> /home/opnfv/.bashrc
+. ${FUNCTEST_REPO_DIR}/functest/cli/functest-complete.sh" \
+>> ${HOME}/.bashrc
subprocess32
shyaml
dnspython
-Pillow==3.3.0
+Pillow==3.3.0
\ No newline at end of file
#. Log in to container and execute the following command. Replace
the IP with installer address after the "-a" parameter::
- $repos_dir/releng/utils/fetch_os_creds.sh \
+ $REPOS_DIR/releng/utils/fetch_os_creds.sh \
-d /home/opnfv/functest/conf/openstack.creds \
-i fuel \
-a 10.20.0.2 \
This file lists the repositories (internal or external) to be cloned in
the Functest container. You can also add external packages::
- RUN git clone https://gerrit.opnfv.org/gerrit/<your project> ${repos_dir}/<your project>
+ RUN git clone https://gerrit.opnfv.org/gerrit/<your project> ${REPOS_DIR}/<your project>
testcases.yaml
--------------
Functest includes a cleaning mechanism in order to remove all the OpenStack
resources except those present before running any test. The script
-*$repos_dir/functest/utils/generate_defaults.py* is called once when setting up
+*$REPOS_DIR/functest/functest/utils/generate_defaults.py* is called once when setting up
the Functest environment (i.e. CLI command 'functest env prepare') to snapshot
all the OpenStack resources (images, networks, volumes, security groups, tenants,
users) so that an eventual cleanup does not remove any of these defaults.
The script **clean_openstack.py** which is located in
-*$repos_dir/functest/utils/* is normally called after a test execution. It is
+*$REPOS_DIR/functest/functest/utils/* is normally called after a test execution. It is
in charge of cleaning the OpenStack resources that are not specified in the
defaults file generated previously which is stored in
*/home/opnfv/functest/conf/os_defaults.yaml* in the Functest docker container.
Although the Functest CLI provides an easy way to run any test, it is possible to
do a direct call to the desired test script. For example:
- python $repos_dir/functest/testcases/OpenStack/vPing/vPing_ssh.py -d
+ python $REPOS_DIR/functest/functest/opnfv_tests/OpenStack/vPing/vPing_ssh.py -d
Automated testing
* mode = (ha|noha)
The constraints per test case are defined in the Functest configuration file
-*/home/opnfv/repos/functest/ci/testcases.yaml*::
+*/home/opnfv/repos/functest/functest/ci/testcases.yaml*::
tiers:
-
The Functest CLI is designed to route a call to the corresponding internal
python scripts, located in paths:
-*$repos_dir/functest/testcases/vPing/CI/libraries/vPing_ssh.py* and
-*$repos_dir/functest/testcases/vPing/CI/libraries/vPing_userdata.py*
+*$REPOS_DIR/functest/functest/opnfv_tests/vPing/CI/libraries/vPing_ssh.py* and
+*$REPOS_DIR/functest/functest/opnfv_tests/vPing/CI/libraries/vPing_userdata.py*
Notes:
#. In this Colorado Funtest Userguide, the use of the Functest CLI is
the second instance **opnfv-vping-2**. The purpose of this is to establish
a SSH connection to that instance and SCP a script that will ping the first
instance. This script is located in the repository under
-*$repos_dir/functest/testcases/OpenStack/vPing/ping.sh* and takes an IP as
+*$REPOS_DIR/functest/functest/opnfv_tests/OpenStack/vPing/ping.sh* and takes an IP as
a parameter. When the SCP is completed, the test will do an SSH call to that script
inside the second instance. Some problems can happen here::
It is possible to run only one Rally scenario, instead of the whole suite.
To do that, call the alternative python script as follows::
- python $repos_dir/functest/testcases/OpenStack/rally/run_rally-cert.py -h
+ python $REPOS_DIR/functest/functest/opnfv_tests/OpenStack/rally/run_rally-cert.py -h
usage: run_rally-cert.py [-h] [-d] [-r] [-s] [-v] [-n] test_name
positional arguments:
For example, to run the Glance scenario with debug information::
- python $repos_dir/functest/testcases/OpenStack/rally/run_rally-cert.py -d glance
+ python $REPOS_DIR/functest/functest/opnfv_tests/OpenStack/rally/run_rally-cert.py -d glance
Possible scenarios are:
* authenticate
* vm
To know more about what those scenarios are doing, they are defined in directory:
-*$repos_dir/functest/testcases/OpenStack/rally/scenario*
+*$REPOS_DIR/functest/functest/opnfv_tests/OpenStack/rally/scenario*
For more info about Rally scenario definition please refer to the Rally official
documentation. `[3]`_
-general:
- directories:
- # Relative to the path where the repo is cloned:
- dir_vping: functest/opnfv_tests/OpenStack/vPing/
- dir_odl: functest/opnfv_tests/Controllers/ODL/
- dir_rally: functest/opnfv_tests/OpenStack/rally/
- dir_tempest_cases: functest/opnfv_tests/OpenStack/tempest/custom_tests/
- dir_vIMS: functest/opnfv_tests/vnf/vIMS/
- dir_onos: functest/opnfv_tests/Controllers/ONOS/Teston/
- dir_onos_sfc: functest/opnfv_tests/Controllers/ONOS/Sfc/
-
- # Absolute path
- dir_repos: /home/opnfv/repos
- dir_repo_functest: /home/opnfv/repos/functest
- dir_repo_rally: /home/opnfv/repos/rally
- dir_repo_tempest: /home/opnfv/repos/tempest
- dir_repo_releng: /home/opnfv/repos/releng
- dir_repo_vims_test: /home/opnfv/repos/vims-test
- dir_repo_bgpvpn: /home/opnfv/repos/bgpvpn
- dir_repo_onos: /home/opnfv/repos/onos
- dir_repo_promise: /home/opnfv/repos/promise
- dir_repo_doctor: /home/opnfv/repos/doctor
- dir_repo_copper: /home/opnfv/repos/copper
- dir_repo_ovno: /home/opnfv/repos/ovno
- dir_repo_parser: /home/opnfv/repos/parser
- dir_repo_domino: /home/opnfv/repos/domino
- dir_functest: /home/opnfv/functest
- dir_results: /home/opnfv/functest/results
- dir_functest_conf: /home/opnfv/functest/conf
- dir_rally_res: /home/opnfv/functest/results/rally/
- dir_functest_data: /home/opnfv/functest/data
- dir_vIMS_data: /home/opnfv/functest/data/vIMS
- dir_rally_inst: /home/opnfv/.rally
-
- openstack:
- snapshot_file: /home/opnfv/functest/conf/openstack_snapshot.yaml
-
- image_name: Cirros-0.3.4
- image_file_name: cirros-0.3.4-x86_64-disk.img
- image_disk_format: qcow2
-
- flavor_name: opnfv_flavor
- flavor_ram: 512
- flavor_disk: 1
- flavor_vcpus: 1
-
- # Private network for functest. Will be created by config_functest.py
- neutron_private_net_name: functest-net
- neutron_private_subnet_name: functest-subnet
- neutron_private_subnet_cidr: 192.168.120.0/24
- neutron_private_subnet_start: 192.168.120.2
- neutron_private_subnet_end: 192.168.120.254
- neutron_private_subnet_gateway: 192.168.120.254
- neutron_router_name: functest-router
-
-healthcheck:
- disk_image: /home/opnfv/functest/data/cirros-0.3.4-x86_64-disk.img
- disk_format: qcow2
- wait_time: 60
-
-vping:
- ping_timeout: 200
- vm_flavor: m1.tiny # adapt to your environment
- vm_name_1: opnfv-vping-1
- vm_name_2: opnfv-vping-2
- image_name: functest-vping
- vping_private_net_name: vping-net
- vping_private_subnet_name: vping-subnet
- vping_private_subnet_cidr: 192.168.130.0/24
- vping_router_name: vping-router
- vping_sg_name: vPing-sg
- vping_sg_descr: Security group for vPing test case
-
-onos_sfc:
- image_name: TestSfcVm
- image_file_name: firewall_block_image.img
-
-tempest:
- identity:
- tenant_name: tempest
- tenant_description: Tenant for Tempest test suite
- user_name: tempest
- user_password: tempest
- validation:
- ssh_timeout: 130
- private_net_name: tempest-net
- private_subnet_name: tempest-subnet
- private_subnet_cidr: 192.168.150.0/24
- router_name: tempest-router
- use_custom_images: False
- use_custom_flavors: False
-
-rally:
- deployment_name: opnfv-rally
- network_name: rally-net
- subnet_name: rally-subnet
- subnet_cidr: 192.168.140.0/24
- router_name: rally-router
-
-vIMS:
- general:
- tenant_name: vIMS
- tenant_description: vIMS Functionality Testing
- images:
- ubuntu:
- image_url: 'http://cloud-images.ubuntu.com/trusty/current/trusty-server-cloudimg-amd64-disk1.img'
- image_name: ubuntu_14.04
- centos:
- image_url: 'http://cloud.centos.org/centos/7/images/CentOS-7-x86_64-GenericCloud-1510.qcow2'
- image_name: centos_7
- cloudify:
- blueprint:
- url: https://github.com/boucherv-orange/cloudify-manager-blueprints.git
- branch: "3.3.1-build"
- requierments:
- ram_min: 3000
- os_image: centos_7
- inputs:
- keystone_username: ""
- keystone_password: ""
- keystone_tenant_name: ""
- keystone_url: ""
- manager_public_key_name: 'manager-kp'
- agent_public_key_name: 'agent-kp'
- image_id: ""
- flavor_id: "3"
- external_network_name: ""
- ssh_user: centos
- agents_user: ubuntu
- clearwater:
- blueprint:
- file_name: 'openstack-blueprint.yaml'
- name: "clearwater-opnfv"
- destination_folder: "opnfv-cloudify-clearwater"
- url: 'https://github.com/Orange-OpenSource/opnfv-cloudify-clearwater.git'
- branch: "stable"
- deployment-name: 'clearwater-opnfv'
- requierments:
- ram_min: 1700
- os_image: ubuntu_14.04
- inputs:
- image_id: ''
- flavor_id: ''
- agent_user: 'ubuntu'
- external_network_name: ''
- public_domain: clearwater.opnfv
-ONOS:
- general:
- onosbench_username: 'root'
- onosbench_password: 'root'
- onoscli_username: 'root'
- onoscli_password: 'root'
- runtimeout: 300
- environment:
- OCT: '10.20.0.1'
- OC1: '10.20.0.7'
- OC2: '10.20.0.7'
- OC3: '10.20.0.7'
- OCN: '10.20.0.4'
- OCN2: '10.20.0.5'
- installer_master: '10.20.0.2'
- installer_master_username: 'root'
- installer_master_password: 'r00tme'
-multisite:
- fuel_environment:
- installer_username: 'root'
- installer_password: 'r00tme'
- compass_environment:
- installer_username: 'root'
- installer_password: 'root'
- multisite_controller_ip: '10.1.0.50'
-promise:
- tenant_name: promise
- tenant_description: promise Functionality Testing
- user_name: promiser
- user_pwd: test
- image_name: promise-img
- flavor_name: promise-flavor
- flavor_vcpus: 1
- flavor_ram: 128
- flavor_disk: 0
- network_name: promise-net
- subnet_name: promise-subnet
- subnet_cidr: 192.168.121.0/24
- router_name: promise-router
-
-example:
- example_vm_name: example-vm
- example_flavor: m1.small
- example_image_name: functest-example-vm
- example_private_net_name: example-net
- example_private_subnet_name: example-subnet
- example_private_subnet_cidr: 192.168.170.0/24
- example_router_name: example-router
- example_sg_name: example-sg
- example_sg_descr: Example Security group
-
-results:
- test_db_url: http://testresults.opnfv.org/test/api/v1
+general:\r
+ directories:\r
+ # Relative to the path where the repo is cloned:\r
+ dir_vping: functest/opnfv_tests/OpenStack/vPing\r
+ dir_odl: functest/opnfv_tests/Controllers/ODL\r
+ dir_rally: functest/opnfv_tests/OpenStack/rally\r
+ dir_tempest_cases: functest/opnfv_tests/OpenStack/tempest/custom_tests\r
+ dir_vIMS: functest/opnfv_tests/vnf/vIMS\r
+ dir_onos: functest/opnfv_tests/Controllers/ONOS/Teston\r
+ dir_onos_sfc: functest/opnfv_tests/Controllers/ONOS/Sfc\r
+\r
+ # Absolute path\r
+ dir_home: /home/opnfv\r
+ dir_repos: /home/opnfv/repos\r
+ dir_repo_functest: /home/opnfv/repos/functest\r
+ dir_repo_rally: /home/opnfv/repos/rally\r
+ dir_repo_tempest: /home/opnfv/repos/tempest\r
+ dir_repo_releng: /home/opnfv/repos/releng\r
+ dir_repo_vims_test: /home/opnfv/repos/vims-test\r
+ dir_repo_sdnvpn: /home/opnfv/repos/sdnvpn\r
+ dir_repo_sfc: /home/opnfv/repos/sfc\r
+ dir_repo_onos: /home/opnfv/repos/onos\r
+ dir_repo_promise: /home/opnfv/repos/promise\r
+ dir_repo_doctor: /home/opnfv/repos/doctor\r
+ dir_repo_copper: /home/opnfv/repos/copper\r
+ dir_repo_ovno: /home/opnfv/repos/ovno\r
+ dir_repo_parser: /home/opnfv/repos/parser\r
+ dir_repo_domino: /home/opnfv/repos/domino\r
+ dir_functest: /home/opnfv/functest\r
+ dir_functest_test: /home/opnfv/repos/functest/functest/opnfv_tests\r
+ dir_results: /home/opnfv/functest/results\r
+ dir_functest_conf: /home/opnfv/functest/conf\r
+ dir_functest_data: /home/opnfv/functest/data\r
+ dir_vIMS_data: /home/opnfv/functest/data/vIMS/\r
+ dir_rally_inst: /home/opnfv/.rally\r
+\r
+ openstack:\r
+ creds: /home/opnfv/functest/conf/openstack.creds\r
+ snapshot_file: /home/opnfv/functest/conf/openstack_snapshot.yaml\r
+\r
+ image_name: Cirros-0.3.4\r
+ image_file_name: cirros-0.3.4-x86_64-disk.img\r
+ image_disk_format: qcow2\r
+\r
+ flavor_name: opnfv_flavor\r
+ flavor_ram: 512\r
+ flavor_disk: 1\r
+ flavor_vcpus: 1\r
+\r
+ # Private network for functest. Will be created by config_functest.py\r
+ neutron_private_net_name: functest-net\r
+ neutron_private_subnet_name: functest-subnet\r
+ neutron_private_subnet_cidr: 192.168.120.0/24\r
+ neutron_private_subnet_start: 192.168.120.2\r
+ neutron_private_subnet_end: 192.168.120.254\r
+ neutron_private_subnet_gateway: 192.168.120.254\r
+ neutron_router_name: functest-router\r
+\r
+ functest:\r
+ testcases_yaml: /home/opnfv/repos/functest/functest/ci/testcases.yaml\r
+\r
+healthcheck:\r
+ disk_image: /home/opnfv/functest/data/cirros-0.3.4-x86_64-disk.img\r
+ disk_format: qcow2\r
+ wait_time: 60\r
+\r
+vping:\r
+ ping_timeout: 200\r
+ vm_flavor: m1.tiny # adapt to your environment\r
+ vm_name_1: opnfv-vping-1\r
+ vm_name_2: opnfv-vping-2\r
+ image_name: functest-vping\r
+ vping_private_net_name: vping-net\r
+ vping_private_subnet_name: vping-subnet\r
+ vping_private_subnet_cidr: 192.168.130.0/24\r
+ vping_router_name: vping-router\r
+ vping_sg_name: vPing-sg\r
+ vping_sg_descr: Security group for vPing test case\r
+\r
+onos_sfc:\r
+ image_base_url: http://artifacts.opnfv.org/sfc/demo\r
+ image_name: TestSfcVm\r
+ image_file_name: firewall_block_image.img\r
+\r
+tempest:\r
+ identity:\r
+ tenant_name: tempest\r
+ tenant_description: Tenant for Tempest test suite\r
+ user_name: tempest\r
+ user_password: tempest\r
+ validation:\r
+ ssh_timeout: 130\r
+ private_net_name: tempest-net\r
+ private_subnet_name: tempest-subnet\r
+ private_subnet_cidr: 192.168.150.0/24\r
+ router_name: tempest-router\r
+ use_custom_images: False\r
+ use_custom_flavors: False\r
+\r
+rally:\r
+ deployment_name: opnfv-rally\r
+ network_name: rally-net\r
+ subnet_name: rally-subnet\r
+ subnet_cidr: 192.168.140.0/24\r
+ router_name: rally-router\r
+\r
+vIMS:\r
+ general:\r
+ tenant_name: vIMS\r
+ tenant_description: vIMS Functionality Testing\r
+ images:\r
+ ubuntu:\r
+ image_url: http://cloud-images.ubuntu.com/trusty/current/trusty-server-cloudimg-amd64-disk1.img\r
+ image_name: ubuntu_14.04\r
+ centos:\r
+ image_url: http://cloud.centos.org/centos/7/images/CentOS-7-x86_64-GenericCloud-1510.qcow2\r
+ image_name: centos_7\r
+ cloudify:\r
+ blueprint:\r
+ url: https://github.com/boucherv-orange/cloudify-manager-blueprints.git\r
+ branch: "3.3.1-build"\r
+ requierments:\r
+ ram_min: 3000\r
+ os_image: centos_7\r
+ inputs:\r
+ keystone_username: ""\r
+ keystone_password: ""\r
+ keystone_tenant_name: ""\r
+ keystone_url: ""\r
+ manager_public_key_name: 'manager-kp'\r
+ agent_public_key_name: 'agent-kp'\r
+ image_id: ""\r
+ flavor_id: "3"\r
+ external_network_name: ""\r
+ ssh_user: centos\r
+ agents_user: ubuntu\r
+ clearwater:\r
+ blueprint:\r
+ file_name: 'openstack-blueprint.yaml'\r
+ name: "clearwater-opnfv"\r
+ destination_folder: "opnfv-cloudify-clearwater"\r
+ url: https://github.com/Orange-OpenSource/opnfv-cloudify-clearwater.git\r
+ branch: "stable"\r
+ deployment-name: 'clearwater-opnfv'\r
+ requierments:\r
+ ram_min: 1700\r
+ os_image: ubuntu_14.04\r
+ inputs:\r
+ image_id: ''\r
+ flavor_id: ''\r
+ agent_user: 'ubuntu'\r
+ external_network_name: ''\r
+ public_domain: clearwater.opnfv\r
+ONOS:\r
+ general:\r
+ onosbench_username: 'root'\r
+ onosbench_password: 'root'\r
+ onoscli_username: 'root'\r
+ onoscli_password: 'root'\r
+ runtimeout: 300\r
+ environment:\r
+ OCT: '10.20.0.1'\r
+ OC1: '10.20.0.7'\r
+ OC2: '10.20.0.7'\r
+ OC3: '10.20.0.7'\r
+ OCN: '10.20.0.4'\r
+ OCN2: '10.20.0.5'\r
+ installer_master: '10.20.0.2'\r
+ installer_master_username: 'root'\r
+ installer_master_password: 'r00tme'\r
+multisite:\r
+ fuel_environment:\r
+ installer_username: 'root'\r
+ installer_password: 'r00tme'\r
+ compass_environment:\r
+ installer_username: 'root'\r
+ installer_password: 'root'\r
+ multisite_controller_ip: '10.1.0.50'\r
+promise:\r
+ tenant_name: promise\r
+ tenant_description: promise Functionality Testing\r
+ user_name: promiser\r
+ user_pwd: test\r
+ image_name: promise-img\r
+ flavor_name: promise-flavor\r
+ flavor_vcpus: 1\r
+ flavor_ram: 128\r
+ flavor_disk: 0\r
+ network_name: promise-net\r
+ subnet_name: promise-subnet\r
+ subnet_cidr: 192.168.121.0/24\r
+ router_name: promise-router\r
+\r
+example:\r
+ example_vm_name: example-vm\r
+ example_flavor: m1.small\r
+ example_image_name: functest-example-vm\r
+ example_private_net_name: example-net\r
+ example_private_subnet_name: example-subnet\r
+ example_private_subnet_cidr: 192.168.170.0/24\r
+ example_router_name: example-router\r
+ example_sg_name: example-sg\r
+ example_sg_descr: Example Security group\r
+\r
+results:\r
+ test_db_url: http://testresults.opnfv.org/test/api/v1\r
"ovno")
# suite under rewritting for colorado
# no need to run anything until refactoring done
- # ${repos_dir}/ovno/Testcases/RunTests.sh
+ # ${REPOS_DIR}/ovno/Testcases/RunTests.sh
;;
"security_scan")
echo "Sourcing Credentials ${FUNCTEST_CONF_DIR}/stackrc for undercloud .."
source ${FUNCTEST_CONF_DIR}/stackrc
- python ${repos_dir}/securityscanning/security_scan.py --config ${repos_dir}/securityscanning/config.ini
+ python ${REPOS_DIR}/securityscanning/security_scan.py --config ${REPOS_DIR}/securityscanning/config.ini
;;
"copper")
python ${FUNCTEST_TEST_DIR}/features/copper.py $report
;;
"moon")
- python ${repos_dir}/moon/tests/run_tests.py $report
+ python ${REPOS_DIR}/moon/tests/run_tests.py $report
;;
"multisite")
python ${FUNCTEST_TEST_DIR}/OpenStack/tempest/gen_tempest_conf.py
-c ${FUNCTEST_TEST_DIR}/OpenStack/tempest/tempest_multisite.conf
;;
"odl-sfc")
- ODL_SFC_DIR=${repos_dir}/sfc/tests/functest/odl-sfc
+ ODL_SFC_DIR=${REPOS_DIR}/sfc/tests/functest/odl-sfc
+ # pass FUNCTEST_REPO_DIR inside prepare_odl_sfc.bash
FUNCTEST_REPO_DIR=${FUNCTEST_REPO_DIR} python ${ODL_SFC_DIR}/prepare_odl_sfc.py || exit $?
source ${ODL_SFC_DIR}/tackerc
python ${ODL_SFC_DIR}/sfc.py $report
# Source credentials
-echo "Sourcing Credentials ${FUNCTEST_CONF_DIR}/openstack.creds to run the test.."
-source ${FUNCTEST_CONF_DIR}/openstack.creds
+echo "Sourcing Credentials ${creds} to run the test.."
+source ${creds}
# ODL Boron workaround to create additional flow rules to allow port 22 TCP
if [[ $DEPLOY_SCENARIO == *"odl_l2-sfc"* ]]; then
import json
-import os
import re
import urllib2
import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
+import functest.utils.functest_constants as ft_constants
COL_1_LEN = 25
# If we run from CI (Jenkins) we will push the results to the DB
# and then we can print the url to the specific test result
-IS_CI_RUN = False
-BUILD_TAG = None
+
+
+class GlobalVariables:
+ IS_CI_RUN = ft_constants.IS_CI_RUN
+ BUILD_TAG = ft_constants.CI_BUILD_TAG
+ INSTALLER = ft_constants.CI_INSTALLER_TYPE
+ CI_LOOP = ft_constants.CI_LOOP
+ SCENARIO = ft_constants.CI_SCENARIO
+
logger = ft_logger.Logger("generate_report").getLogger()
def get_results_from_db():
- url = ft_utils.get_db_url() + '/results?build_tag=' + BUILD_TAG
+ url = ft_utils.get_db_url() + '/results?build_tag=' \
+ + GlobalVariables.BUILD_TAG
logger.debug("Query to rest api: %s" % url)
try:
data = json.load(urllib2.urlopen(url))
'| ' + w2.ljust(COL_2_LEN - 1) +
'| ' + w3.ljust(COL_3_LEN - 1) +
'| ' + w4.ljust(COL_4_LEN - 1))
- if IS_CI_RUN:
+ if GlobalVariables.IS_CI_RUN:
str += ('| ' + w5.ljust(COL_5_LEN - 1))
str += '|\n'
return str
def print_line_no_columns(str):
TOTAL_LEN = COL_1_LEN + COL_2_LEN + COL_3_LEN + COL_4_LEN + 2
- if IS_CI_RUN:
+ if GlobalVariables.IS_CI_RUN:
TOTAL_LEN += COL_5_LEN + 1
return ('| ' + str.ljust(TOTAL_LEN) + "|\n")
delimiter + char * COL_2_LEN +
delimiter + char * COL_3_LEN +
delimiter + char * COL_4_LEN)
- if IS_CI_RUN:
+ if GlobalVariables.IS_CI_RUN:
str += (delimiter + char * COL_5_LEN)
str += '+\n'
return str
def main(args):
- global BUILD_TAG, IS_CI_RUN
executed_test_cases = args
- BUILD_TAG = os.getenv("BUILD_TAG")
- if BUILD_TAG is not None:
- IS_CI_RUN = True
-
- if IS_CI_RUN:
+ if GlobalVariables.IS_CI_RUN:
results = get_results_from_db()
if results is not None:
for test in executed_test_cases:
"result": data['result']})
TOTAL_LEN = COL_1_LEN + COL_2_LEN + COL_3_LEN + COL_4_LEN
- if IS_CI_RUN:
+ if GlobalVariables.IS_CI_RUN:
TOTAL_LEN += COL_5_LEN
MID = TOTAL_LEN / 2
- INSTALLER = os.getenv('INSTALLER_TYPE', 'unknown')
- CI_LOOP = os.getenv('CI_LOOP')
- SCENARIO = os.getenv('DEPLOY_SCENARIO')
- CI_LOOP = None
- if BUILD_TAG is not None:
- if re.search("daily", BUILD_TAG) is not None:
- CI_LOOP = "daily"
+ if GlobalVariables.BUILD_TAG is not None:
+ if re.search("daily", GlobalVariables.BUILD_TAG) is not None:
+ GlobalVariables.CI_LOOP = "daily"
else:
- CI_LOOP = "weekly"
+ GlobalVariables.CI_LOOP = "weekly"
str = ''
str += print_separator('=', delimiter="=")
str += print_separator('=', delimiter="=")
str += print_line_no_columns(' ')
str += print_line_no_columns(" Deployment description:")
- str += print_line_no_columns(" INSTALLER: %s" % INSTALLER)
- if SCENARIO is not None:
- str += print_line_no_columns(" SCENARIO: %s" % SCENARIO)
- if BUILD_TAG is not None:
- str += print_line_no_columns(" BUILD TAG: %s" % BUILD_TAG)
- if CI_LOOP is not None:
- str += print_line_no_columns(" CI LOOP: %s" % CI_LOOP)
+ str += print_line_no_columns(" INSTALLER: %s"
+ % GlobalVariables.INSTALLER)
+ if GlobalVariables.SCENARIO is not None:
+ str += print_line_no_columns(" SCENARIO: %s"
+ % GlobalVariables.SCENARIO)
+ if GlobalVariables.BUILD_TAG is not None:
+ str += print_line_no_columns(" BUILD TAG: %s"
+ % GlobalVariables.BUILD_TAG)
+ if GlobalVariables.CI_LOOP is not None:
+ str += print_line_no_columns(" CI LOOP: %s"
+ % GlobalVariables.CI_LOOP)
str += print_line_no_columns(' ')
str += print_separator('=')
- if IS_CI_RUN:
+ if GlobalVariables.IS_CI_RUN:
str += print_line('TEST CASE', 'TIER', 'DURATION', 'RESULT', 'URL')
else:
str += print_line('TEST CASE', 'TIER', 'DURATION', 'RESULT')
import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
import functest.utils.openstack_utils as os_utils
+import functest.utils.functest_constants as ft_constants
actions = ['start', 'check']
parser = argparse.ArgumentParser()
logger = ft_logger.Logger("prepare_env").getLogger()
-""" global variables """
-INSTALLERS = ['fuel', 'compass', 'apex', 'joid']
-CI_INSTALLER_TYPE = ""
-CI_INSTALLER_IP = ""
-CI_SCENARIO = ""
-CI_DEBUG = False
-CONFIG_FUNCTEST_PATH = os.environ["CONFIG_FUNCTEST_YAML"]
+CONFIG_FUNCTEST_PATH = ft_constants.CONFIG_FUNCTEST_YAML
CONFIG_PATCH_PATH = os.path.join(os.path.dirname(
CONFIG_FUNCTEST_PATH), "config_patch.yaml")
with open(CONFIG_PATCH_PATH) as f:
functest_patch_yaml = yaml.safe_load(f)
-FUNCTEST_CONF_DIR = \
- ft_utils.get_functest_config('general.directories.dir_functest_conf')
-
-
-FUNCTEST_DATA_DIR = \
- ft_utils.get_functest_config('general.directories.dir_functest_data')
-FUNCTEST_RESULTS_DIR = \
- ft_utils.get_functest_config('general.directories.dir_results')
-DEPLOYMENT_MAME = \
- ft_utils.get_functest_config('rally.deployment_name')
-TEMPEST_REPO_DIR = \
- ft_utils.get_functest_config('general.directories.dir_repo_tempest')
-
-ENV_FILE = FUNCTEST_CONF_DIR + "/env_active"
-
def print_separator():
logger.info("==============================================")
def check_env_variables():
print_separator()
logger.info("Checking environment variables...")
- global CI_INSTALLER_TYPE
- global CI_INSTALLER_IP
- global CI_DEBUG
- global CI_SCENARIO
- CI_INSTALLER_TYPE = os.getenv('INSTALLER_TYPE')
- CI_INSTALLER_IP = os.getenv('INSTALLER_IP')
- CI_SCENARIO = os.getenv('DEPLOY_SCENARIO')
- CI_NODE = os.getenv('NODE_NAME')
- CI_BUILD_TAG = os.getenv('BUILD_TAG')
- CI_DEBUG = os.getenv('CI_DEBUG')
-
- if CI_INSTALLER_TYPE is None:
+
+ if ft_constants.CI_INSTALLER_TYPE is None:
logger.warning("The env variable 'INSTALLER_TYPE' is not defined.")
- CI_INSTALLER_TYPE = "undefined"
+ ft_constants.CI_INSTALLER_TYPE = "undefined"
else:
- if CI_INSTALLER_TYPE not in INSTALLERS:
+ if ft_constants.CI_INSTALLER_TYPE not in ft_constants.INSTALLERS:
logger.warning("INSTALLER_TYPE=%s is not a valid OPNFV installer. "
"Available OPNFV Installers are : %s. "
"Setting INSTALLER_TYPE=undefined."
- % (CI_INSTALLER_TYPE, INSTALLERS))
- CI_INSTALLER_TYPE = "undefined"
+ % (ft_constants.CI_INSTALLER_TYPE,
+ ft_constants.INSTALLERS))
+ ft_constants.CI_INSTALLER_TYPE = "undefined"
else:
- logger.info(" INSTALLER_TYPE=%s" % CI_INSTALLER_TYPE)
+ logger.info(" INSTALLER_TYPE=%s"
+ % ft_constants.CI_INSTALLER_TYPE)
- if CI_INSTALLER_IP is None:
+ if ft_constants.CI_INSTALLER_IP is None:
logger.warning("The env variable 'INSTALLER_IP' is not defined. "
"It is needed to fetch the OpenStack credentials. "
"If the credentials are not provided to the "
"container as a volume, please add this env variable "
"to the 'docker run' command.")
else:
- logger.info(" INSTALLER_IP=%s" % CI_INSTALLER_IP)
+ logger.info(" INSTALLER_IP=%s" % ft_constants.CI_INSTALLER_IP)
- if CI_SCENARIO is None:
+ if ft_constants.CI_SCENARIO is None:
logger.warning("The env variable 'DEPLOY_SCENARIO' is not defined. "
"Setting CI_SCENARIO=undefined.")
- CI_SCENARIO = "undefined"
+ ft_constants.CI_SCENARIO = "undefined"
else:
- logger.info(" DEPLOY_SCENARIO=%s" % CI_SCENARIO)
- if CI_DEBUG:
- logger.info(" CI_DEBUG=%s" % CI_DEBUG)
+ logger.info(" DEPLOY_SCENARIO=%s" % ft_constants.CI_SCENARIO)
+ if ft_constants.CI_DEBUG:
+ logger.info(" CI_DEBUG=%s" % ft_constants.CI_DEBUG)
- if CI_NODE:
- logger.info(" NODE_NAME=%s" % CI_NODE)
+ if ft_constants.CI_NODE:
+ logger.info(" NODE_NAME=%s" % ft_constants.CI_NODE)
- if CI_BUILD_TAG:
- logger.info(" BUILD_TAG=%s" % CI_BUILD_TAG)
+ if ft_constants.CI_BUILD_TAG:
+ logger.info(" BUILD_TAG=%s" % ft_constants.CI_BUILD_TAG)
+
+ if ft_constants.IS_CI_RUN:
+ logger.info(" IS_CI_RUN=%s" % ft_constants.IS_CI_RUN)
def create_directories():
print_separator()
logger.info("Creating needed directories...")
- if not os.path.exists(FUNCTEST_CONF_DIR):
- os.makedirs(FUNCTEST_CONF_DIR)
- logger.info(" %s created." % FUNCTEST_CONF_DIR)
+ if not os.path.exists(ft_constants.FUNCTEST_CONF_DIR):
+ os.makedirs(ft_constants.FUNCTEST_CONF_DIR)
+ logger.info(" %s created." % ft_constants.FUNCTEST_CONF_DIR)
else:
- logger.debug(" %s already exists." % FUNCTEST_CONF_DIR)
+ logger.debug(" %s already exists."
+ % ft_constants.FUNCTEST_CONF_DIR)
- if not os.path.exists(FUNCTEST_DATA_DIR):
- os.makedirs(FUNCTEST_DATA_DIR)
- logger.info(" %s created." % FUNCTEST_DATA_DIR)
+ if not os.path.exists(ft_constants.FUNCTEST_DATA_DIR):
+ os.makedirs(ft_constants.FUNCTEST_DATA_DIR)
+ logger.info(" %s created." % ft_constants.FUNCTEST_DATA_DIR)
else:
- logger.debug(" %s already exists." % FUNCTEST_DATA_DIR)
+ logger.debug(" %s already exists."
+ % ft_constants.FUNCTEST_DATA_DIR)
def source_rc_file():
print_separator()
logger.info("Fetching RC file...")
- rc_file = os.getenv('creds')
- if rc_file is None:
+
+ if ft_constants.OPENSTACK_CREDS is None:
logger.warning("The environment variable 'creds' must be set and"
"pointing to the local RC file. Using default: "
"/home/opnfv/functest/conf/openstack.creds ...")
- rc_file = "/home/opnfv/functest/conf/openstack.creds"
+ ft_constants.OPENSTACK_CREDS = \
+ "/home/opnfv/functest/conf/openstack.creds"
- if not os.path.isfile(rc_file):
+ if not os.path.isfile(ft_constants.OPENSTACK_CREDS):
logger.info("RC file not provided. "
"Fetching it from the installer...")
- if CI_INSTALLER_IP is None:
+ if ft_constants.CI_INSTALLER_IP is None:
logger.error("The env variable CI_INSTALLER_IP must be provided in"
" order to fetch the credentials from the installer.")
sys.exit("Missing CI_INSTALLER_IP.")
- if CI_INSTALLER_TYPE not in INSTALLERS:
+ if ft_constants.CI_INSTALLER_TYPE not in ft_constants.INSTALLERS:
logger.error("Cannot fetch credentials. INSTALLER_TYPE=%s is "
"not a valid OPNFV installer. Available "
- "installers are : %s." % INSTALLERS)
+ "installers are : %s." % ft_constants.INSTALLERS)
sys.exit("Wrong INSTALLER_TYPE.")
cmd = ("/home/opnfv/repos/releng/utils/fetch_os_creds.sh "
"-d %s -i %s -a %s"
- % (rc_file, CI_INSTALLER_TYPE, CI_INSTALLER_IP))
+ % (ft_constants.OPENSTACK_CREDS,
+ ft_constants.CI_INSTALLER_TYPE,
+ ft_constants.CI_INSTALLER_IP))
logger.debug("Executing command: %s" % cmd)
p = subprocess.Popen(cmd.split(), stdout=subprocess.PIPE)
output = p.communicate()[0]
logger.error("Failed to fetch credentials from installer.")
sys.exit(1)
else:
- logger.info("RC file provided in %s." % rc_file)
- if os.path.getsize(rc_file) == 0:
- logger.error("The file %s is empty." % rc_file)
+ logger.info("RC file provided in %s."
+ % ft_constants.OPENSTACK_CREDS)
+ if os.path.getsize(ft_constants.OPENSTACK_CREDS) == 0:
+ logger.error("The file %s is empty."
+ % ft_constants.OPENSTACK_CREDS)
sys.exit(1)
logger.info("Sourcing the OpenStack RC file...")
- creds = os_utils.source_credentials(rc_file)
+ creds = os_utils.source_credentials(
+ ft_constants.OPENSTACK_CREDS)
str = ""
for key, value in creds.iteritems():
if re.search("OS_", key):
str += "\n\t\t\t\t\t\t " + key + "=" + value
+ if key == 'OS_AUTH_URL':
+ ft_constants.OS_AUTH_URL = value
+ elif key == 'OS_USERNAME':
+ ft_constants.OS_USERNAME = value
+ elif key == 'OS_TENANT_NAME':
+ ft_constants.OS_TENANT_NAME = value
+ elif key == 'OS_PASSWORD':
+ ft_constants.OS_PASSWORD = value
logger.debug("Used credentials: %s" % str)
+ logger.debug("OS_AUTH_URL:%s" % ft_constants.OS_AUTH_URL)
+ logger.debug("OS_USERNAME:%s" % ft_constants.OS_USERNAME)
+ logger.debug("OS_TENANT_NAME:%s" % ft_constants.OS_TENANT_NAME)
+ logger.debug("OS_PASSWORD:%s" % ft_constants.OS_PASSWORD)
def patch_config_file():
updated = False
for key in functest_patch_yaml:
- if key in CI_SCENARIO:
+ if key in ft_constants.CI_SCENARIO:
new_functest_yaml = dict(ft_utils.merge_dicts(
ft_utils.get_functest_yaml(), functest_patch_yaml[key]))
updated = True
def verify_deployment():
print_separator()
logger.info("Verifying OpenStack services...")
- cmd = ("%s/functest/ci/check_os.sh" % ft_utils.FUNCTEST_REPO)
+ cmd = ("%s/functest/ci/check_os.sh" % ft_constants.FUNCTEST_REPO_DIR)
logger.debug("Executing command: %s" % cmd)
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True)
logger.info("Creating Rally environment...")
cmd = "rally deployment destroy opnfv-rally"
- ft_utils.execute_command(cmd,
- error_msg=("Deployment %s does not exist."
- % DEPLOYMENT_MAME), verbose=False)
+ ft_utils.execute_command(cmd, error_msg=(
+ "Deployment %s does not exist."
+ % ft_constants.RALLY_DEPLOYMENT_NAME),
+ verbose=False)
rally_conf = os_utils.get_credentials_for_rally()
with open('rally_conf.json', 'w') as fp:
json.dump(rally_conf, fp)
cmd = "rally deployment create --file=rally_conf.json --name="
- cmd += DEPLOYMENT_MAME
+ cmd += ft_constants.RALLY_DEPLOYMENT_NAME
ft_utils.execute_command(cmd,
error_msg="Problem creating Rally deployment")
logger.info("Installing tempest from existing repo...")
- cmd = ("rally verify install --source " + TEMPEST_REPO_DIR +
+ cmd = ("rally verify install --source " +
+ ft_constants.TEMPEST_REPO_DIR +
" --system-wide")
ft_utils.execute_command(cmd,
error_msg="Problem installing Tempest.")
def check_environment():
msg_not_active = "The Functest environment is not installed."
- if not os.path.isfile(ENV_FILE):
+ if not os.path.isfile(ft_constants.ENV_FILE):
logger.error(msg_not_active)
sys.exit(1)
- with open(ENV_FILE, "r") as env_file:
+ with open(ft_constants.ENV_FILE, "r") as env_file:
s = env_file.read()
if not re.search("1", s):
logger.error(msg_not_active)
verify_deployment()
install_rally()
- with open(ENV_FILE, "w") as env_file:
+ with open(ft_constants.ENV_FILE, "w") as env_file:
env_file.write("1")
check_environment()
exit(0)
+
if __name__ == '__main__':
main()
import functest.core.TestCasesBase as TestCasesBase
import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
+import functest.utils.functest_constants as ft_constants
import functest.utils.openstack_clean as os_clean
import functest.utils.openstack_snapshot as os_snapshot
import functest.utils.openstack_utils as os_utils
""" global variables """
-EXEC_SCRIPT = ("%s/functest/ci/exec_test.sh" % ft_utils.FUNCTEST_REPO)
-CLEAN_FLAG = True
-REPORT_FLAG = False
-EXECUTED_TEST_CASES = []
+EXEC_SCRIPT = ("%s/functest/ci/exec_test.sh" % ft_constants.FUNCTEST_REPO_DIR)
# This will be the return code of this script. If any of the tests fails,
# this variable will change to -1
-OVERALL_RESULT = 0
+
+
+class GlobalVariables:
+ EXECUTED_TEST_CASES = []
+ OVERALL_RESULT = 0
+ CLEAN_FLAG = True
+ REPORT_FLAG = False
def print_separator(str, count=45):
def source_rc_file():
- rc_file = os.getenv('creds')
+ rc_file = ft_constants.OPENSTACK_CREDS
if not os.path.isfile(rc_file):
logger.error("RC file %s does not exist..." % rc_file)
sys.exit(1)
logger.debug("Sourcing the OpenStack RC file...")
- os_utils.source_credentials(rc_file)
+ creds = os_utils.source_credentials(rc_file)
+ for key, value in creds.iteritems():
+ if re.search("OS_", key):
+ if key == 'OS_AUTH_URL':
+ ft_constants.OS_AUTH_URL = value
+ elif key == 'OS_USERNAME':
+ ft_constants.OS_USERNAME = value
+ elif key == 'OS_TENANT_NAME':
+ ft_constants.OS_TENANT_NAME = value
+ elif key == 'OS_PASSWORD':
+ ft_constants.OS_PASSWORD = value
+ logger.debug("OS_AUTH_URL:%s" % ft_constants.OS_AUTH_URL)
+ logger.debug("OS_USERNAME:%s" % ft_constants.OS_USERNAME)
+ logger.debug("OS_TENANT_NAME:%s" % ft_constants.OS_TENANT_NAME)
+ logger.debug("OS_PASSWORD:%s" % ft_constants.OS_PASSWORD)
def generate_os_snapshot():
def update_test_info(test_name, result, duration):
- for test in EXECUTED_TEST_CASES:
+ for test in GlobalVariables.EXECUTED_TEST_CASES:
if test['test_name'] == test_name:
test.update({"result": result,
"duration": duration})
def run_test(test, tier_name):
- global OVERALL_RESULT, EXECUTED_TEST_CASES
result_str = "PASS"
start = datetime.datetime.now()
test_name = test.get_name()
print_separator("=")
logger.debug("\n%s" % test)
- if CLEAN_FLAG:
+ if GlobalVariables.CLEAN_FLAG:
generate_os_snapshot()
flags = (" -t %s" % (test_name))
- if REPORT_FLAG:
+ if GlobalVariables.REPORT_FLAG:
flags += " -r"
result = TestCasesBase.TestCasesBase.EX_RUN_ERROR
cls = getattr(module, run_dict['class'])
test_case = cls()
result = test_case.run()
- if result != TestCasesBase.TestCasesBase.EX_SKIP and REPORT_FLAG:
+
+ if result != TestCasesBase.TestCasesBase.EX_SKIP and \
+ GlobalVariables.REPORT_FLAG:
test_case.push_to_db()
except ImportError:
logger.exception("Cannot import module {}".format(
cmd, test_name))
result = ft_utils.execute_command(cmd)
- if CLEAN_FLAG:
+ if GlobalVariables.CLEAN_FLAG:
cleanup()
end = datetime.datetime.now()
duration = (end - start).seconds
"execution.")
# if it is a single test we don't print the whole results table
update_test_info(test_name, result_str, duration_str)
- generate_report.main(EXECUTED_TEST_CASES)
+ generate_report.main(GlobalVariables.EXECUTED_TEST_CASES)
logger.info("Execution exit value: %s" % OVERALL_RESULT)
sys.exit(OVERALL_RESULT)
def run_all(tiers):
- global EXECUTED_TEST_CASES
summary = ""
- BUILD_TAG = os.getenv('BUILD_TAG')
+ BUILD_TAG = ft_constants.CI_BUILD_TAG
if BUILD_TAG is not None and re.search("daily", BUILD_TAG) is not None:
CI_LOOP = "daily"
else:
tier.get_test_names()))
logger.info("Tests to be executed:%s" % summary)
- EXECUTED_TEST_CASES = generate_report.init(tiers_to_run)
+ GlobalVariables.EXECUTED_TEST_CASES = generate_report.init(tiers_to_run)
for tier in tiers_to_run:
run_tier(tier)
- generate_report.main(EXECUTED_TEST_CASES)
+ generate_report.main(GlobalVariables.EXECUTED_TEST_CASES)
def main():
- global CLEAN_FLAG
- global REPORT_FLAG
- CI_INSTALLER_TYPE = os.getenv('INSTALLER_TYPE')
- CI_SCENARIO = os.getenv('DEPLOY_SCENARIO')
+ CI_INSTALLER_TYPE = ft_constants.CI_INSTALLER_TYPE
+ CI_SCENARIO = ft_constants.CI_SCENARIO
- file = ft_utils.get_testcases_file()
+ file = ft_constants.FUNCTEST_TESTCASES_YAML
_tiers = tb.TierBuilder(CI_INSTALLER_TYPE, CI_SCENARIO, file)
if args.noclean:
- CLEAN_FLAG = False
+ GlobalVariables.CLEAN_FLAG = False
if args.report:
- REPORT_FLAG = True
+ GlobalVariables.REPORT_FLAG = True
if args.test:
source_rc_file()
else:
run_all(_tiers)
- logger.info("Execution exit value: %s" % OVERALL_RESULT)
- sys.exit(OVERALL_RESULT)
+ logger.info("Execution exit value: %s" % GlobalVariables.OVERALL_RESULT)
+ sys.exit(GlobalVariables.OVERALL_RESULT)
+
if __name__ == '__main__':
main()
dependencies:
installer: '(fuel)|(apex)'
scenario: 'bgpvpn'
- run:
+ run:
module: 'functest.opnfv_tests.features.sdnvpn'
class: 'SDNVPN'
def cli():
pass
+
_env = CliEnv()
_openstack = CliOpenStack()
_testcase = CliTestcase()
import git
import functest.utils.functest_utils as ft_utils
-
-ENV_FILE = "/home/opnfv/functest/conf/env_active"
-FUNCTEST_REPO = ft_utils.FUNCTEST_REPO
+import functest.utils.functest_constants as ft_constants
class CliEnv:
"it again? [y|n]\n")
while True:
if answer.lower() in ["y", "yes"]:
- os.remove(ENV_FILE)
+ os.remove(ft_constants.ENV_FILE)
break
elif answer.lower() in ["n", "no"]:
return
else:
answer = raw_input("Invalid answer. Please type [y|n]\n")
- cmd = ("python %s/functest/ci/prepare_env.py start" % FUNCTEST_REPO)
+ cmd = ("python %s/functest/ci/prepare_env.py start" %
+ ft_constants.FUNCTEST_REPO_DIR)
ft_utils.execute_command(cmd)
def show(self):
- CI_INSTALLER_TYPE = os.getenv('INSTALLER_TYPE')
+ CI_INSTALLER_TYPE = ft_constants.CI_INSTALLER_TYPE
if CI_INSTALLER_TYPE is None:
CI_INSTALLER_TYPE = "Unknown"
- CI_INSTALLER_IP = os.getenv('INSTALLER_IP')
+ CI_INSTALLER_IP = ft_constants.CI_INSTALLER_IP
if CI_INSTALLER_IP is None:
CI_INSTALLER_IP = "Unknown"
CI_INSTALLER = ("%s, %s" % (CI_INSTALLER_TYPE, CI_INSTALLER_IP))
- CI_SCENARIO = os.getenv('DEPLOY_SCENARIO')
+ CI_SCENARIO = ft_constants.CI_SCENARIO
if CI_SCENARIO is None:
CI_SCENARIO = "Unknown"
- CI_NODE = os.getenv('NODE_NAME')
+ CI_NODE = ft_constants.CI_NODE
if CI_NODE is None:
CI_NODE = "Unknown"
- repo = git.Repo(FUNCTEST_REPO)
+ repo = git.Repo(ft_constants.FUNCTEST_REPO_DIR)
branch = repo.head.reference
GIT_BRANCH = branch.name
GIT_HASH = branch.commit.hexsha
- CI_BUILD_TAG = os.getenv('BUILD_TAG')
+ CI_BUILD_TAG = ft_constants.CI_BUILD_TAG
if CI_BUILD_TAG is not None:
CI_BUILD_TAG = CI_BUILD_TAG.lstrip(
"jenkins-").lstrip("functest").lstrip("-")
- CI_DEBUG = os.getenv('CI_DEBUG')
+ CI_DEBUG = ft_constants.CI_DEBUG
if CI_DEBUG is None:
CI_DEBUG = "false"
def status(self, verbose=True):
ret_val = 0
- if not os.path.isfile(ENV_FILE):
+ if not os.path.isfile(ft_constants.ENV_FILE):
if verbose:
click.echo("Functest environment is not installed.\n")
ret_val = 1
import functest.utils.functest_utils as ft_utils
import functest.utils.openstack_clean as os_clean
import functest.utils.openstack_snapshot as os_snapshot
+import functest.utils.functest_constants as ft_constants
-FUNCTEST_CONF_DIR = \
- ft_utils.get_functest_config('general.directories.dir_functest_conf')
-RC_FILE = os.getenv('creds')
-OS_SNAPSHOT_FILE = \
- ft_utils.get_functest_config("general.openstack.snapshot_file")
+OPENSTACK_RC_FILE = ft_constants.OPENSTACK_CREDS
+OPENSTACK_SNAPSHOT_FILE = ft_constants.OPENSTACK_SNAPSHOT_FILE
class CliOpenStack:
def __init__(self):
- self.os_auth_url = os.getenv('OS_AUTH_URL')
+ self.os_auth_url = ft_constants.OS_AUTH_URL
self.endpoint_ip = None
self.endpoint_port = None
if self.os_auth_url is not None:
click.echo("{}={}".format(key, value))
def fetch_credentials(self):
- if os.path.isfile(RC_FILE):
+ if os.path.isfile(OPENSTACK_RC_FILE):
answer = raw_input("It seems the RC file is already present. "
"Do you want to overwrite it? [y|n]\n")
while True:
else:
answer = raw_input("Invalid answer. Please type [y|n]\n")
- CI_INSTALLER_TYPE = os.getenv('INSTALLER_TYPE')
+ CI_INSTALLER_TYPE = ft_constants.CI_INSTALLER_TYPE
if CI_INSTALLER_TYPE is None:
click.echo("The environment variable 'INSTALLER_TYPE' is not"
"defined. Please export it")
- CI_INSTALLER_IP = os.getenv('INSTALLER_IP')
+ CI_INSTALLER_IP = ft_constants.CI_INSTALLER_IP
if CI_INSTALLER_IP is None:
click.echo("The environment variable 'INSTALLER_IP' is not"
"defined. Please export it")
- cmd = ("/home/opnfv/repos/releng/utils/fetch_os_creds.sh "
- "-d %s -i %s -a %s"
- % (RC_FILE, CI_INSTALLER_TYPE, CI_INSTALLER_IP))
+ cmd = ft_constants.REPOS_DIR + \
+ ("/releng/utils/fetch_os_creds.sh "
+ "-d %s -i %s -a %s"
+ % (OPENSTACK_RC_FILE, CI_INSTALLER_TYPE, CI_INSTALLER_IP))
click.echo("Fetching credentials from installer node '%s' with IP=%s.."
% (CI_INSTALLER_TYPE, CI_INSTALLER_IP))
ft_utils.execute_command(cmd, verbose=False)
def check(self):
self.ping_endpoint()
- cmd = ft_utils.FUNCTEST_REPO + "/functest/ci/check_os.sh"
+ cmd = ft_constants.FUNCTEST_REPO_DIR + "/functest/ci/check_os.sh"
ft_utils.execute_command(cmd, verbose=False)
def snapshot_create(self):
self.ping_endpoint()
- if os.path.isfile(OS_SNAPSHOT_FILE):
+ if os.path.isfile(OPENSTACK_SNAPSHOT_FILE):
answer = raw_input("It seems there is already an OpenStack "
"snapshot. Do you want to overwrite it with "
"the current OpenStack status? [y|n]\n")
os_snapshot.main()
def snapshot_show(self):
- if not os.path.isfile(OS_SNAPSHOT_FILE):
+ if not os.path.isfile(OPENSTACK_SNAPSHOT_FILE):
click.echo("There is no OpenStack snapshot created. To create "
"one run the command "
"'functest openstack snapshot-create'")
return
- with open(OS_SNAPSHOT_FILE, 'r') as yaml_file:
+ with open(OPENSTACK_SNAPSHOT_FILE, 'r') as yaml_file:
click.echo("\n%s"
% yaml_file.read())
def clean(self):
self.ping_endpoint()
- if not os.path.isfile(OS_SNAPSHOT_FILE):
+ if not os.path.isfile(OPENSTACK_SNAPSHOT_FILE):
click.echo("Not possible to clean OpenStack without a snapshot. "
"This could cause problems. "
"Run first the command "
import functest.ci.tier_builder as tb
import functest.utils.functest_utils as ft_utils
import functest.utils.functest_vacation as vacation
-
-
-FUNCTEST_CONF_DIR = \
- ft_utils.get_functest_config('general.directories.dir_functest_conf')
-ENV_FILE = FUNCTEST_CONF_DIR + "/env_active"
-FUNCTEST_REPO = ft_utils.FUNCTEST_REPO
+import functest.utils.functest_constants as ft_constants
class CliTestcase:
def __init__(self):
- CI_INSTALLER_TYPE = os.getenv('INSTALLER_TYPE')
- CI_SCENARIO = os.getenv('DEPLOY_SCENARIO')
- testcases = ft_utils.get_testcases_file()
+ CI_INSTALLER_TYPE = ft_constants.CI_INSTALLER_TYPE
+ CI_SCENARIO = ft_constants.CI_SCENARIO
+ testcases = ft_constants.FUNCTEST_TESTCASES_YAML
+
self.tiers = tb.TierBuilder(CI_INSTALLER_TYPE, CI_SCENARIO, testcases)
def list(self):
def run(self, testname, noclean=False):
if testname == 'vacation':
vacation.main()
- elif not os.path.isfile(ENV_FILE):
+ elif not os.path.isfile(ft_constants.ENV_FILE):
click.echo("Functest environment is not ready. "
"Run first 'functest env prepare'")
else:
if noclean:
cmd = ("python %s/functest/ci/run_tests.py "
- "-n -t %s" % (FUNCTEST_REPO, testname))
+ "-n -t %s" % (ft_constants.FUNCTEST_REPO_DIR, testname))
else:
cmd = ("python %s/functest/ci/run_tests.py "
- "-t %s" % (FUNCTEST_REPO, testname))
+ "-t %s" % (ft_constants.FUNCTEST_REPO_DIR, testname))
ft_utils.execute_command(cmd)
import functest.ci.tier_builder as tb
import functest.utils.functest_utils as ft_utils
-
-
-FUNCTEST_CONF_DIR = \
- ft_utils.get_functest_config('general.directories.dir_functest_conf')
-ENV_FILE = FUNCTEST_CONF_DIR + "/env_active"
-FUNCTEST_REPO = ft_utils.FUNCTEST_REPO
+import functest.utils.functest_constants as ft_constants
class CliTier:
def __init__(self):
- CI_INSTALLER_TYPE = os.getenv('INSTALLER_TYPE')
- CI_SCENARIO = os.getenv('DEPLOY_SCENARIO')
- testcases = ft_utils.get_testcases_file()
+ CI_INSTALLER_TYPE = ft_constants.CI_INSTALLER_TYPE
+ CI_SCENARIO = ft_constants.CI_SCENARIO
+ testcases = ft_constants.FUNCTEST_TESTCASES_YAML
self.tiers = tb.TierBuilder(CI_INSTALLER_TYPE, CI_SCENARIO, testcases)
def list(self):
click.echo("Test cases in tier '%s':\n %s\n" % (tiername, tests))
def run(self, tiername, noclean=False):
- if not os.path.isfile(ENV_FILE):
+ if not os.path.isfile(ft_constants.ENV_FILE):
click.echo("Functest environment is not ready. "
"Run first 'functest env prepare'")
else:
if noclean:
cmd = ("python %s/functest/ci/run_tests.py "
- "-n -t %s" % (FUNCTEST_REPO, tiername))
+ "-n -t %s" % (ft_constants.FUNCTEST_REPO_DIR, tiername))
else:
cmd = ("python %s/functest/ci/run_tests.py "
- "-t %s" % (FUNCTEST_REPO, tiername))
+ "-t %s" % (ft_constants.FUNCTEST_REPO_DIR, tiername))
ft_utils.execute_command(cmd)
import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
+import functest.utils.functest_constants as ft_constants
class TestCasesBase(object):
logger = ft_logger.Logger(__name__).getLogger()
def __init__(self):
- self.functest_repo = ft_utils.FUNCTEST_REPO
+ self.functest_repo = ft_constants.FUNCTEST_REPO_DIR
self.details = {}
self.project_name = "functest"
self.case_name = ""
from functest.core import TestCasesBase
import functest.utils.functest_logger as ft_logger
import functest.utils.openstack_utils as op_utils
+import functest.utils.functest_constants as ft_constants
class ODLResultVisitor(ResultVisitor):
class ODLTestCases(TestCasesBase.TestCasesBase):
- repos = "/home/opnfv/repos/"
- odl_test_repo = repos + "odl_test/"
- neutron_suite_dir = odl_test_repo + "csit/suites/openstack/neutron/"
- basic_suite_dir = odl_test_repo + "csit/suites/integration/basic/"
- res_dir = '/home/opnfv/functest/results/odl/'
+ repos = ft_constants.REPOS_DIR
+ odl_test_repo = os.path.join(repos, "odl_test")
+ neutron_suite_dir = os.path.join(odl_test_repo,
+ "csit/suites/openstack/neutron")
+ basic_suite_dir = os.path.join(odl_test_repo,
+ "csit/suites/integration/basic")
+ res_dir = os.path.join(ft_constants.FUNCTEST_RESULTS_DIR, "odl")
+
logger = ft_logger.Logger("opendaylight").getLogger()
def __init__(self):
@classmethod
def set_robotframework_vars(cls, odlusername="admin", odlpassword="admin"):
- odl_variables_files = cls.odl_test_repo + 'csit/variables/Variables.py'
+ odl_variables_files = os.path.join(cls.odl_test_repo,
+ 'csit/variables/Variables.py')
try:
for line in fileinput.input(odl_variables_files,
inplace=True):
return False
def parse_results(self):
- result = ExecutionResult(self.res_dir + 'output.xml')
+ output_dir = os.path.join(self.res_dir, 'output.xml')
+ result = ExecutionResult(output_dir)
visitor = ODLResultVisitor()
result.visit(visitor)
self.criteria = result.suite.status
self.logger.exception(
"Cannot create {}".format(self.res_dir))
return self.EX_RUN_ERROR
- stdout_file = self.res_dir + 'stdout.txt'
+ stdout_file = os.path.join(self.res_dir, 'stdout.txt')
+ output_dir = os.path.join(self.res_dir, 'output.xml')
with open(stdout_file, 'w+') as stdout:
robot.run(*dirs, variable=variables,
- output=self.res_dir + 'output.xml',
+ output=output_dir,
log='NONE',
report='NONE',
stdout=stdout)
kwargs['odlrestconfport'] = '8181'
kwargs['odlusername'] = 'admin'
kwargs['odlpassword'] = 'admin'
- installer_type = None
- if 'INSTALLER_TYPE' in os.environ:
- installer_type = os.environ['INSTALLER_TYPE']
- kwargs['osusername'] = os.environ['OS_USERNAME']
- kwargs['ostenantname'] = os.environ['OS_TENANT_NAME']
- kwargs['ospassword'] = os.environ['OS_PASSWORD']
+
+ installer_type = ft_constants.CI_INSTALLER_TYPE
+ kwargs['osusername'] = ft_constants.OS_USERNAME
+ kwargs['ostenantname'] = ft_constants.OS_TENANT_NAME
+ kwargs['ospassword'] = ft_constants.OS_PASSWORD
+
if installer_type == 'fuel':
kwargs['odlwebport'] = '8282'
elif installer_type == 'apex':
- kwargs['odlip'] = os.environ['SDN_CONTROLLER_IP']
+ if ft_constants.SDN_CONTROLLER_IP is None:
+ return self.EX_RUN_ERROR
+ kwargs['odlip'] = ft_constants.SDN_CONTROLLER_IP
kwargs['odlwebport'] = '8181'
elif installer_type == 'joid':
- kwargs['odlip'] = os.environ['SDN_CONTROLLER']
+ if ft_constants.SDN_CONTROLLER is None:
+ return self.EX_RUN_ERROR
+ kwargs['odlip'] = ft_constants.SDN_CONTROLLER
elif installer_type == 'compass':
kwargs['odlwebport'] = '8181'
else:
- kwargs['odlip'] = os.environ['SDN_CONTROLLER_IP']
+ if ft_constants.SDN_CONTROLLER_IP is None:
+ return self.EX_RUN_ERROR
+ kwargs['odlip'] = ft_constants.SDN_CONTROLLER_IP
except KeyError as e:
self.logger.error("Cannot run ODL testcases. "
"Please check env var: "
return self.main(**kwargs)
+
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('-k', '--keystoneip',
import time
import functest.utils.functest_logger as ft_logger
-import functest.utils.functest_utils as functest_utils
+import functest.utils.functest_utils as ft_utils
from Sfc_fun import Sfc_fun
logger = ft_logger.Logger("sfc").getLogger()
logger.info(
"Testcase 4 : Configure Port Chain and verify flows are added")
logger.info("4.1 Creation of Port Chain")
- check(Sfc_obj.createPortChain, CREATED, "Creation of Port Chain")
+ check(Sfc_obj.createPortChain, CREATED, "Creation of Port Chain")
def VerifySfcTraffic():
# ONOS SFC success criteria = all tests OK
duration = round(stop_time - start_time, 1)
logger.info("Result is " + status)
- functest_utils.push_results_to_db("functest",
- "onos_sfc",
- start_time,
- stop_time,
- status,
- details={'duration': duration,
- 'error': info})
+ ft_utils.push_results_to_db("functest",
+ "onos_sfc",
+ start_time,
+ stop_time,
+ status,
+ details={'duration': duration,
+ 'error': info})
except:
logger.error("Error pushing results into Database")
result = self.CheckSshNoPasswd(host)
if not result:
self.logger.info(
- "ssh login failed,try to copy master publickey" +
- "to agent " + str(host))
+ "ssh login failed,try to copy master publickey" +
+ "to agent " + str(host))
self.CopyPublicKey(host)
self.OnosPushKeys(handle, "onos-push-keys " + self.OCT, masterpass)
self.OnosPushKeys(handle, "onos-push-keys " + self.OC1, agentpass)
import re
import time
+import functest.utils.functest_constants as ft_constants
import functest.utils.functest_utils as ft_utils
def __init__(self):
# currentpath = os.getcwd()
- REPO_PATH = ft_utils.FUNCTEST_REPO + '/'
- currentpath = REPO_PATH + 'opnfv_tests/Controllers/ONOS/Teston/CI'
+ currentpath = \
+ ft_constants.FUNCTEST_TEST_DIR + '/Controllers/ONOS/Teston/CI'
self.cipath = currentpath
self.logdir = os.path.join(currentpath, 'log')
self.workhome = currentpath[0: currentpath.rfind('opnfv_tests') - 1]
"""
Get Default Parameters value
"""
- self.Result_DB = str(
- ft_utils.get_functest_config('results.test_db_url'))
- self.masterusername = str(
- ft_utils.get_functest_config('ONOS.general.onosbench_username'))
- self.masterpassword = str(
- ft_utils.get_functest_config('ONOS.general.onosbench_password'))
- self.agentusername = str(
- ft_utils.get_functest_config('ONOS.general.onoscli_username'))
- self.agentpassword = str(
- ft_utils.get_functest_config('ONOS.general.onoscli_password'))
- self.runtimeout = \
- ft_utils.get_functest_config('ONOS.general.runtimeout')
- self.OCT = str(ft_utils.get_functest_config('ONOS.environment.OCT'))
- self.OC1 = str(ft_utils.get_functest_config('ONOS.environment.OC1'))
- self.OC2 = str(ft_utils.get_functest_config('ONOS.environment.OC2'))
- self.OC3 = str(ft_utils.get_functest_config('ONOS.environment.OC3'))
- self.OCN = str(ft_utils.get_functest_config('ONOS.environment.OCN'))
- self.OCN2 = str(ft_utils.get_functest_config('ONOS.environment.OCN2'))
- self.installer_master = str(
- ft_utils.get_functest_config('ONOS.environment.installer_master'))
- self.installer_master_username = str(ft_utils.get_functest_config(
- 'ONOS.environment.installer_master_username'))
- self.installer_master_password = str(ft_utils.get_functest_config(
- 'ONOS.environment.installer_master_password'))
+ self.Result_DB = str(ft_utils.get_db_url())
+ self.masterusername = str(ft_constants.ONOSBENCH_USERNAME)
+ self.masterpassword = str(ft_constants.ONOSBENCH_PASSWORD)
+ self.agentusername = str(ft_constants.ONOSCLI_USERNAME)
+ self.agentpassword = str(ft_constants.ONOSCLI_PASSWORD)
+ self.runtimeout = ft_constants.ONOS_RUNTIMEOUT
+ self.OCT = str(ft_constants.ONOS_OCT)
+ self.OC1 = str(ft_constants.ONOS_OC1)
+ self.OC2 = str(ft_constants.ONOS_OC2)
+ self.OC3 = str(ft_constants.ONOS_OC3)
+ self.OCN = str(ft_constants.ONOS_OCN)
+ self.OCN2 = str(ft_constants.ONOS_OCN2)
+ self.installer_master = str(ft_constants.ONOS_INSTALLER_MASTER)
+ self.installer_master_username = \
+ str(ft_constants.ONOS_INSTALLER_MASTER_USERNAME)
+ self.installer_master_password = \
+ ft_constants.ONOS_INSTALLER_MASTER_PASSWORD
self.hosts = [self.OC1, self.OCN, self.OCN2]
self.localhost = self.OCT
import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
import functest.utils.openstack_utils as openstack_utils
+import functest.utils.functest_constants as ft_constants
+
parser = argparse.ArgumentParser()
parser.add_argument("-t", "--testcase", help="Testcase name")
logger = ft_logger.Logger("onos").getLogger()
# onos parameters
-TEST_DB = ft_utils.get_functest_config("results.test_db_url")
-ONOS_REPO_PATH = \
- ft_utils.get_functest_config("general.directories.dir_repos")
-ONOS_CONF_DIR = \
- ft_utils.get_functest_config("general.directories.dir_functest_conf")
-
-ONOSCI_PATH = ONOS_REPO_PATH + "/"
+ONOSCI_PATH = ft_constants.REPOS_DIR + "/"
starttime = datetime.datetime.now()
-HOME = os.environ['HOME'] + "/"
-INSTALLER_TYPE = os.environ['INSTALLER_TYPE']
-DEPLOY_SCENARIO = os.environ['DEPLOY_SCENARIO']
-ONOSCI_PATH = ONOS_REPO_PATH + "/"
-GLANCE_IMAGE_NAME = ft_utils.get_functest_config("onos_sfc.image_name")
-GLANCE_IMAGE_FILENAME = \
- ft_utils.get_functest_config("onos_sfc.image_file_name")
-GLANCE_IMAGE_PATH = \
- ft_utils.get_functest_config("general.directories.dir_functest_data") + \
- "/" + GLANCE_IMAGE_FILENAME
-SFC_PATH = ft_utils.FUNCTEST_REPO + "/" + \
- ft_utils.get_functest_config("general.directories.dir_onos_sfc")
+INSTALLER_TYPE = ft_constants.CI_INSTALLER_TYPE
+ONOS_SFC_IMAGE_NAME = ft_constants.ONOS_SFC_IMAGE_NAME
+ONOS_SFC_IMAGE_PATH = os.path.join(ft_constants.FUNCTEST_DATA_DIR,
+ ft_constants.ONOS_SFC_IMAGE_FILENAME)
+ONOS_SFC_PATH = os.path.join(ft_constants.FUNCTEST_REPO_DIR,
+ ft_constants.ONOS_SFC_RELATIVE_PATH)
def RunScript(testname):
def CreateImage():
glance_client = openstack_utils.get_glance_client()
image_id = openstack_utils.create_glance_image(glance_client,
- GLANCE_IMAGE_NAME,
- GLANCE_IMAGE_PATH)
+ ONOS_SFC_IMAGE_NAME,
+ ONOS_SFC_IMAGE_PATH)
EXIT_CODE = -1
if not image_id:
logger.error("Failed to create a Glance image...")
return(EXIT_CODE)
logger.debug("Image '%s' with ID=%s created successfully."
- % (GLANCE_IMAGE_NAME, image_id))
+ % (ONOS_SFC_IMAGE_NAME, image_id))
def SfcTest():
- cmd = "python " + SFC_PATH + "Sfc.py"
+ cmd = "python " + ONOS_SFC_PATH + "/Sfc.py"
logger.debug("Run sfc tests")
os.system(cmd)
def Replace(before, after):
- file = "Sfc_fun.py"
- cmd = "sed -i 's/" + before + "/" + after + "/g' " + SFC_PATH + file
+ file = "/Sfc_fun.py"
+ cmd = "sed -i 's/" + before + "/" + after + "/g' " + ONOS_SFC_PATH + file
os.system(cmd)
Replace("neutron_ip", GetIp("neutron"))
Replace("nova_ip", GetIp("nova"))
Replace("glance_ip", GetIp("glance"))
- pwd = os.environ['OS_PASSWORD']
+ pwd = ft_constants.OS_PASSWORD
Replace("console", pwd)
creds_neutron = openstack_utils.get_credentials("neutron")
neutron_client = neutronclient.Client(**creds_neutron)
else:
OnosTest()
+
if __name__ == '__main__':
main()
#
import argparse
-import os
import sys
import functest.utils.functest_logger as ft_logger
-import functest.utils.functest_utils as ft_utils
import functest.utils.openstack_utils as os_utils
+import functest.utils.functest_constants as ft_constants
parser = argparse.ArgumentParser()
""" logging configuration """
logger = ft_logger.Logger("create_instance_and_ip").getLogger()
-HOME = os.environ['HOME'] + "/"
+HOME = ft_constants.HOME + "/"
VM_BOOT_TIMEOUT = 180
-INSTANCE_NAME = ft_utils.get_functest_config("example.example_vm_name")
-FLAVOR = ft_utils.get_functest_config("example.example_flavor")
-IMAGE_NAME = ft_utils.get_functest_config("example.example_image_name")
-IMAGE_FILENAME = \
- ft_utils.get_functest_config("general.openstack.image_file_name")
-IMAGE_FORMAT = \
- ft_utils.get_functest_config("general.openstack.image_disk_format")
-IMAGE_PATH = \
- ft_utils.get_functest_config("general.directories.dir_functest_data") + \
+EXAMPLE_INSTANCE_NAME = ft_constants.EXAMPLE_INSTANCE_NAME
+EXAMPLE_FLAVOR = ft_constants.EXAMPLE_FLAVOR
+EXAMPLE_IMAGE_NAME = ft_constants.EXAMPLE_IMAGE_NAME
+IMAGE_FILENAME = ft_constants.GLANCE_IMAGE_FILENAME
+IMAGE_FORMAT = ft_constants.GLANCE_IMAGE_FORMAT
+IMAGE_PATH = ft_constants.FUNCTEST_DATA_DIR + \
"/" + IMAGE_FILENAME
# NEUTRON Private Network parameters
-NET_NAME = ft_utils.get_functest_config("example.example_private_net_name")
-SUBNET_NAME = \
- ft_utils.get_functest_config("example.example_private_subnet_name")
-SUBNET_CIDR = \
- ft_utils.get_functest_config("example.example_private_subnet_cidr")
-ROUTER_NAME = ft_utils.get_functest_config("example.example_router_name")
+EXAMPLE_PRIVATE_NET_NAME = ft_constants.EXAMPLE_PRIVATE_NET_NAME
+EXAMPLE_PRIVATE_SUBNET_NAME = ft_constants.EXAMPLE_PRIVATE_SUBNET_NAME
+EXAMPLE_PRIVATE_SUBNET_CIDR = ft_constants.EXAMPLE_PRIVATE_SUBNET_CIDR
+EXAMPLE_ROUTER_NAME = ft_constants.EXAMPLE_ROUTER_NAME
-SECGROUP_NAME = ft_utils.get_functest_config("example.example_sg_name")
-SECGROUP_DESCR = ft_utils.get_functest_config("example.example_sg_descr")
-
-TEST_DB = ft_utils.get_functest_config("results.test_db_url")
+EXAMPLE_SECGROUP_NAME = ft_constants.EXAMPLE_SECGROUP_NAME
+EXAMPLE_SECGROUP_DESCR = ft_constants.EXAMPLE_SECGROUP_DESCR
def main():
glance_client = os_utils.get_glance_client()
image_id = os_utils.create_glance_image(glance_client,
- IMAGE_NAME,
+ EXAMPLE_IMAGE_NAME,
IMAGE_PATH,
disk=IMAGE_FORMAT,
container="bare",
public=True)
network_dic = os_utils.create_network_full(neutron_client,
- NET_NAME,
- SUBNET_NAME,
- ROUTER_NAME,
- SUBNET_CIDR)
+ EXAMPLE_PRIVATE_NET_NAME,
+ EXAMPLE_PRIVATE_SUBNET_NAME,
+ EXAMPLE_ROUTER_NAME,
+ EXAMPLE_PRIVATE_SUBNET_CIDR)
if not network_dic:
logger.error(
"There has been a problem when creating the neutron network")
network_id = network_dic["net_id"]
sg_id = os_utils.create_security_group_full(neutron_client,
- SECGROUP_NAME, SECGROUP_DESCR)
+ EXAMPLE_SECGROUP_NAME,
+ EXAMPLE_SECGROUP_DESCR)
# boot INTANCE
- logger.info("Creating instance '%s'..." % INSTANCE_NAME)
+ logger.info("Creating instance '%s'..." % EXAMPLE_INSTANCE_NAME)
logger.debug(
"Configuration:\n name=%s \n flavor=%s \n image=%s \n "
- "network=%s \n" % (INSTANCE_NAME, FLAVOR, image_id, network_id))
- instance = os_utils.create_instance_and_wait_for_active(FLAVOR,
- image_id,
- network_id,
- INSTANCE_NAME)
+ "network=%s \n"
+ % (EXAMPLE_INSTANCE_NAME, EXAMPLE_FLAVOR, image_id, network_id))
+ instance = \
+ os_utils.create_instance_and_wait_for_active(EXAMPLE_FLAVOR,
+ image_id,
+ network_id,
+ EXAMPLE_INSTANCE_NAME)
if instance is None:
logger.error("Error while booting instance.")
sys.exit(-1)
# Retrieve IP of INSTANCE
- instance_ip = instance.networks.get(NET_NAME)[0]
+ instance_ip = instance.networks.get(EXAMPLE_PRIVATE_NET_NAME)[0]
logger.debug("Instance '%s' got private ip '%s'." %
- (INSTANCE_NAME, instance_ip))
+ (EXAMPLE_INSTANCE_NAME, instance_ip))
logger.info("Adding '%s' to security group '%s'..."
- % (INSTANCE_NAME, SECGROUP_NAME))
+ % (EXAMPLE_INSTANCE_NAME, EXAMPLE_SECGROUP_NAME))
os_utils.add_secgroup_to_instance(nova_client, instance.id, sg_id)
- logger.info("Creating floating IP for VM '%s'..." % INSTANCE_NAME)
+ logger.info("Creating floating IP for VM '%s'..." % EXAMPLE_INSTANCE_NAME)
floatip_dic = os_utils.create_floating_ip(neutron_client)
floatip = floatip_dic['fip_addr']
# floatip_id = floatip_dic['fip_id']
logger.info("Floating IP created: '%s'" % floatip)
logger.info("Associating floating ip: '%s' to VM '%s' "
- % (floatip, INSTANCE_NAME))
+ % (floatip, EXAMPLE_INSTANCE_NAME))
if not os_utils.add_floating_ip(nova_client, instance.id, floatip):
logger.error("Cannot associate floating IP to VM.")
sys.exit(-1)
sys.exit(0)
+
if __name__ == '__main__':
main()
import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
import functest.utils.openstack_utils as os_utils
+import functest.utils.functest_constants as ft_constants
tests = ['authenticate', 'glance', 'cinder', 'heat', 'keystone',
'neutron', 'nova', 'quotas', 'requests', 'vm', 'all']
args = parser.parse_args()
-network_dict = {}
if args.verbose:
RALLY_STDERR = subprocess.STDOUT
RALLY_STDERR = open(os.devnull, 'w')
""" logging configuration """
-logger = ft_logger.Logger("run_rally").getLogger()
-
-
-HOME = os.environ['HOME'] + "/"
-RALLY_DIR = ft_utils.FUNCTEST_REPO + '/' + \
- ft_utils.get_functest_config('general.directories.dir_rally')
-SANITY_MODE_DIR = RALLY_DIR + "scenario/sanity"
-FULL_MODE_DIR = RALLY_DIR + "scenario/full"
-TEMPLATE_DIR = RALLY_DIR + "scenario/templates"
-SUPPORT_DIR = RALLY_DIR + "scenario/support"
-TEMP_DIR = RALLY_DIR + "var"
-BLACKLIST_FILE = RALLY_DIR + "blacklist.txt"
+logger = ft_logger.Logger("run_rally-cert").getLogger()
+
+RALLY_DIR = os.path.join(ft_constants.FUNCTEST_REPO_DIR,
+ ft_constants.RALLY_RELATIVE_PATH)
+RALLY_SCENARIO_DIR = os.path.join(RALLY_DIR, "scenario")
+SANITY_MODE_DIR = os.path.join(RALLY_SCENARIO_DIR, "sanity")
+FULL_MODE_DIR = os.path.join(RALLY_SCENARIO_DIR, "full")
+TEMPLATE_DIR = os.path.join(RALLY_SCENARIO_DIR, "templates")
+SUPPORT_DIR = os.path.join(RALLY_SCENARIO_DIR, "support")
+TEMP_DIR = os.path.join(RALLY_DIR, "var")
+BLACKLIST_FILE = os.path.join(RALLY_DIR, "blacklist.txt")
FLAVOR_NAME = "m1.tiny"
USERS_AMOUNT = 2
ITERATIONS_AMOUNT = 10
CONCURRENCY = 4
-RESULTS_DIR = \
- ft_utils.get_functest_config('general.directories.dir_rally_res')
-TEMPEST_CONF_FILE = \
- ft_utils.get_functest_config('general.directories.dir_results') + \
- '/tempest/tempest.conf'
-TEST_DB = ft_utils.get_functest_config('results.test_db_url')
-
-PRIVATE_NET_NAME = ft_utils.get_functest_config('rally.network_name')
-PRIVATE_SUBNET_NAME = ft_utils.get_functest_config('rally.subnet_name')
-PRIVATE_SUBNET_CIDR = ft_utils.get_functest_config('rally.subnet_cidr')
-ROUTER_NAME = ft_utils.get_functest_config('rally.router_name')
-
-GLANCE_IMAGE_NAME = \
- ft_utils.get_functest_config('general.openstack.image_name')
-GLANCE_IMAGE_FILENAME = \
- ft_utils.get_functest_config('general.openstack.image_file_name')
-GLANCE_IMAGE_FORMAT = \
- ft_utils.get_functest_config('general.openstack.image_disk_format')
-GLANCE_IMAGE_PATH = \
- ft_utils.get_functest_config('general.directories.dir_functest_data') + \
- "/" + GLANCE_IMAGE_FILENAME
+RESULTS_DIR = os.path.join(ft_constants.FUNCTEST_RESULTS_DIR, 'rally')
+TEMPEST_CONF_FILE = os.path.join(ft_constants.FUNCTEST_RESULTS_DIR,
+ 'tempest/tempest.conf')
+RALLY_PRIVATE_NET_NAME = ft_constants.RALLY_PRIVATE_NET_NAME
+RALLY_PRIVATE_SUBNET_NAME = ft_constants.RALLY_PRIVATE_SUBNET_NAME
+RALLY_PRIVATE_SUBNET_CIDR = ft_constants.RALLY_PRIVATE_SUBNET_CIDR
+RALLY_ROUTER_NAME = ft_constants.RALLY_ROUTER_NAME
+
+GLANCE_IMAGE_NAME = ft_constants.GLANCE_IMAGE_NAME
+GLANCE_IMAGE_FILENAME = ft_constants.GLANCE_IMAGE_FILENAME
+GLANCE_IMAGE_FORMAT = ft_constants.GLANCE_IMAGE_FORMAT
+GLANCE_IMAGE_PATH = os.path.join(ft_constants.FUNCTEST_DATA_DIR,
+ GLANCE_IMAGE_FILENAME)
CINDER_VOLUME_TYPE_NAME = "volume_test"
-SUMMARY = []
-neutron_client = None
+class GlobalVariables:
+ SUMMARY = []
+ neutron_client = None
+ network_dict = {}
def get_task_id(cmd_raw):
else:
task_args['smoke'] = args.smoke
- ext_net = os_utils.get_external_net(neutron_client)
+ ext_net = os_utils.get_external_net(GlobalVariables.neutron_client)
if ext_net:
task_args['floating_network'] = str(ext_net)
else:
task_args['floating_network'] = ''
- net_id = network_dict['net_id']
+ net_id = GlobalVariables.network_dict['net_id']
task_args['netid'] = str(net_id)
- auth_url = os.getenv('OS_AUTH_URL')
+ auth_url = ft_constants.OS_AUTH_URL
if auth_url is not None:
task_args['request_url'] = auth_url.rsplit(":", 1)[0]
else:
def get_output(proc, test_name):
- global SUMMARY
result = ""
nb_tests = 0
overall_duration = 0.0
'overall_duration': overall_duration,
'nb_tests': nb_tests,
'success': success_avg}
- SUMMARY.append(scenario_summary)
+ GlobalVariables.SUMMARY.append(scenario_summary)
logger.debug("\n" + result)
with open(BLACKLIST_FILE, 'r') as black_list_file:
black_list_yaml = yaml.safe_load(black_list_file)
- installer_type = os.getenv('INSTALLER_TYPE')
- deploy_scenario = os.getenv('DEPLOY_SCENARIO')
+ installer_type = ft_constants.CI_INSTALLER_TYPE
+ deploy_scenario = ft_constants.CI_SCENARIO
if (bool(installer_type) * bool(deploy_scenario)):
if 'scenario' in black_list_yaml.keys():
for item in black_list_yaml['scenario']:
def prepare_test_list(test_name):
- scenario_file_name = '{}opnfv-{}.yaml'.format(RALLY_DIR + "scenario/",
- test_name)
+ test_yaml_file_name = 'opnfv-{}.yaml'.format(test_name)
+ scenario_file_name = os.path.join(RALLY_SCENARIO_DIR, test_yaml_file_name)
+
if not os.path.exists(scenario_file_name):
if args.sanity:
- scenario_file_name = '{}opnfv-{}.yaml'.format(SANITY_MODE_DIR +
- "/", test_name)
+ scenario_file_name = os.path.join(SANITY_MODE_DIR,
+ test_yaml_file_name)
else:
- scenario_file_name = '{}opnfv-{}.yaml'.format(FULL_MODE_DIR +
- "/", test_name)
+ scenario_file_name = os.path.join(FULL_MODE_DIR,
+ test_yaml_file_name)
+
if not os.path.exists(scenario_file_name):
logger.info("The scenario '%s' does not exist."
% scenario_file_name)
exit(-1)
logger.debug('Scenario fetched from : {}'.format(scenario_file_name))
- test_file_name = '{}opnfv-{}.yaml'.format(TEMP_DIR + "/", test_name)
+ test_file_name = os.path.join(TEMP_DIR, test_yaml_file_name)
if not os.path.exists(TEMP_DIR):
os.makedirs(TEMP_DIR)
# :param test_name: name for the rally test
# :return: void
#
- global SUMMARY
logger.info('Starting test scenario "{}" ...'.format(test_name))
start_time = time.time()
- task_file = '{}task.yaml'.format(RALLY_DIR)
+ task_file = os.path.join(RALLY_DIR, 'task.yaml')
if not os.path.exists(task_file):
logger.error("Task file '%s' does not exist." % task_file)
exit(-1)
os.makedirs(RESULTS_DIR)
# write html report file
- report_file_name = '{}opnfv-{}.html'.format(RESULTS_DIR, test_name)
+ report_html_name = 'opnfv-{}.html'.format(test_name)
+ report_html_dir = os.path.join(RESULTS_DIR, report_html_name)
cmd_line = "rally task report {} --out {}".format(task_id,
- report_file_name)
+ report_html_dir)
logger.debug('running command line : {}'.format(cmd_line))
os.popen(cmd_line)
logger.debug('running command line : {}'.format(cmd_line))
cmd = os.popen(cmd_line)
json_results = cmd.read()
- with open('{}opnfv-{}.json'.format(RESULTS_DIR, test_name), 'w') as f:
+ report_json_name = 'opnfv-{}.json'.format(test_name)
+ report_json_dir = os.path.join(RESULTS_DIR, report_json_name)
+ with open(report_json_dir, 'w') as f:
logger.debug('saving json file')
f.write(json_results)
- with open('{}opnfv-{}.json'
- .format(RESULTS_DIR, test_name)) as json_file:
+ with open(report_json_dir) as json_file:
json_data = json.load(json_file)
""" parse JSON operation result """
def main():
- global SUMMARY
- global network_dict
- global neutron_client
- nova_client = os_utils.get_nova_client()
- neutron_client = os_utils.get_neutron_client()
+ GlobalVariables.nova_client = os_utils.get_nova_client()
+ GlobalVariables.neutron_client = os_utils.get_neutron_client()
cinder_client = os_utils.get_cinder_client()
start_time = time.time()
logger.error('argument not valid')
exit(-1)
- SUMMARY = []
+ GlobalVariables.SUMMARY = []
volume_types = os_utils.list_volume_types(cinder_client,
private=False)
if not image_id:
exit(-1)
- logger.debug("Creating network '%s'..." % PRIVATE_NET_NAME)
- network_dict = os_utils.create_shared_network_full(PRIVATE_NET_NAME,
- PRIVATE_SUBNET_NAME,
- ROUTER_NAME,
- PRIVATE_SUBNET_CIDR)
- if not network_dict:
+ logger.debug("Creating network '%s'..." % RALLY_PRIVATE_NET_NAME)
+ GlobalVariables.network_dict = \
+ os_utils.create_shared_network_full(RALLY_PRIVATE_NET_NAME,
+ RALLY_PRIVATE_SUBNET_NAME,
+ RALLY_ROUTER_NAME,
+ RALLY_PRIVATE_SUBNET_CIDR)
+ if not GlobalVariables.network_dict:
exit(1)
if args.test_name == "all":
total_duration = 0.0
total_nb_tests = 0
total_success = 0.0
- for s in SUMMARY:
+ for s in GlobalVariables.SUMMARY:
name = "{0:<17}".format(s['test_name'])
duration = float(s['overall_duration'])
total_duration += duration
total_duration_str2 = "{0:<10}".format(total_duration_str)
total_nb_tests_str = "{0:<13}".format(total_nb_tests)
- if len(SUMMARY):
- success_rate = total_success / len(SUMMARY)
+ if len(GlobalVariables.SUMMARY):
+ success_rate = total_success / len(GlobalVariables.SUMMARY)
else:
success_rate = 100
success_rate = "{:0.2f}".format(success_rate)
if not image_exists:
logger.debug("Deleting image '%s' with ID '%s'..."
% (GLANCE_IMAGE_NAME, image_id))
- if not os_utils.delete_glance_image(nova_client, image_id):
+ if not os_utils.delete_glance_image(GlobalVariables.nova_client,
+ image_id):
logger.error("Error deleting the glance image")
if not volume_types:
import functest.utils.functest_logger as ft_logger
from run_tempest import configure_tempest
from run_tempest import TEMPEST_RESULTS_DIR
+import functest.utils.functest_constants as ft_constants
-logger = ft_logger.Logger("multisite").getLogger()
+logger = ft_logger.Logger("gen_tempest_conf").getLogger()
+
+CI_INSTALLER_TYPE = ft_constants.CI_INSTALLER_TYPE
+CI_INSTALLER_IP = ft_constants.CI_INSTALLER_IP
def configure_tempest_multisite(deployment_dir):
configure_tempest(deployment_dir)
logger.debug("Finding tempest.conf file...")
- tempest_conf_file = deployment_dir + "/tempest.conf"
- if not os.path.isfile(tempest_conf_file):
+ tempest_conf_old = os.path.join(deployment_dir, '/tempest.conf')
+ if not os.path.isfile(tempest_conf_old):
logger.error("Tempest configuration file %s NOT found."
- % tempest_conf_file)
+ % tempest_conf_old)
exit(-1)
# Copy tempest.conf to /home/opnfv/functest/results/tempest/
cur_path = os.path.split(os.path.realpath(__file__))[0]
- shutil.copyfile(tempest_conf_file, cur_path + '/tempest_multisite.conf')
- tempest_conf_file = cur_path + "/tempest_multisite.conf"
+ tempest_conf_file = os.path.join(cur_path, '/tempest_multisite.conf')
+ shutil.copyfile(tempest_conf_old, tempest_conf_file)
logger.debug("Updating selected tempest.conf parameters...")
config = ConfigParser.RawConfigParser()
cmd = "openstack endpoint show kingbird | grep publicurl |\
awk '{print $4}' | awk -F '/' '{print $4}'"
kingbird_api_version = os.popen(cmd).read()
- if os.environ.get("INSTALLER_TYPE") == 'fuel':
+ if CI_INSTALLER_TYPE == 'fuel':
# For MOS based setup, the service is accessible
# via bind host
kingbird_conf_path = "/etc/kingbird/kingbird.conf"
- installer_type = os.getenv('INSTALLER_TYPE', 'Unknown')
- installer_ip = os.getenv('INSTALLER_IP', 'Unknown')
+ installer_type = CI_INSTALLER_TYPE
+ installer_ip = CI_INSTALLER_IP
installer_username = ft_utils.get_functest_config(
"multisite." + installer_type +
"_environment.installer_username")
import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
import functest.utils.openstack_utils as os_utils
+import functest.utils.functest_constants as ft_constants
modes = ['full', 'smoke', 'baremetal', 'compute', 'data_processing',
'identity', 'image', 'network', 'object_storage', 'orchestration',
""" logging configuration """
logger = ft_logger.Logger("run_tempest").getLogger()
-TEST_DB = ft_utils.get_functest_config('results.test_db_url')
-
-MODE = "smoke"
-GLANCE_IMAGE_NAME = \
- ft_utils.get_functest_config('general.openstack.image_name')
-GLANCE_IMAGE_FILENAME = \
- ft_utils.get_functest_config('general.openstack.image_file_name')
-GLANCE_IMAGE_FORMAT = \
- ft_utils.get_functest_config('general.openstack.image_disk_format')
-GLANCE_IMAGE_PATH = \
- ft_utils.get_functest_config('general.directories.dir_functest_data') + \
+GLANCE_IMAGE_NAME = ft_constants.GLANCE_IMAGE_NAME
+GLANCE_IMAGE_FILENAME = ft_constants.GLANCE_IMAGE_FILENAME
+GLANCE_IMAGE_FORMAT = ft_constants.GLANCE_IMAGE_FORMAT
+GLANCE_IMAGE_PATH = ft_constants.FUNCTEST_DATA_DIR + \
"/" + GLANCE_IMAGE_FILENAME
-IMAGE_ID = None
IMAGE_ID_ALT = None
-FLAVOR_NAME = \
- ft_utils.get_functest_config('general.openstack.flavor_name')
-FLAVOR_RAM = ft_utils.get_functest_config('general.openstack.flavor_ram')
-FLAVOR_DISK = ft_utils.get_functest_config('general.openstack.flavor_disk')
-FLAVOR_VCPUS = ft_utils.get_functest_config('general.openstack.flavor_vcpus')
-FLAVOR_ID = None
+FLAVOR_NAME = ft_constants.FLAVOR_NAME
+FLAVOR_RAM = ft_constants.FLAVOR_RAM
+FLAVOR_DISK = ft_constants.FLAVOR_DISK
+FLAVOR_VCPUS = ft_constants.FLAVOR_VCPUS
FLAVOR_ID_ALT = None
-PRIVATE_NET_NAME = \
- ft_utils.get_functest_config('tempest.private_net_name')
-PRIVATE_SUBNET_NAME = \
- ft_utils.get_functest_config('tempest.private_subnet_name')
-PRIVATE_SUBNET_CIDR = \
- ft_utils.get_functest_config('tempest.private_subnet_cidr')
-ROUTER_NAME = \
- ft_utils.get_functest_config('tempest.router_name')
-TENANT_NAME = \
- ft_utils.get_functest_config('tempest.identity.tenant_name')
-TENANT_DESCRIPTION = \
- ft_utils.get_functest_config('tempest.identity.tenant_description')
-USER_NAME = \
- ft_utils.get_functest_config('tempest.identity.user_name')
-USER_PASSWORD = \
- ft_utils.get_functest_config('tempest.identity.user_password')
-SSH_TIMEOUT = \
- ft_utils.get_functest_config('tempest.validation.ssh_timeout')
-USE_CUSTOM_IMAGES = \
- ft_utils.get_functest_config('tempest.use_custom_images')
-USE_CUSTOM_FLAVORS = \
- ft_utils.get_functest_config('tempest.use_custom_flavors')
-
-DEPLOYMENT_MAME = \
- ft_utils.get_functest_config('rally.deployment_name')
-RALLY_INSTALLATION_DIR = \
- ft_utils.get_functest_config('general.directories.dir_rally_inst')
-
-RESULTS_DIR = \
- ft_utils.get_functest_config('general.directories.dir_results')
-TEMPEST_RESULTS_DIR = RESULTS_DIR + '/tempest'
-
-REPO_PATH = ft_utils.FUNCTEST_REPO + '/'
-TEST_LIST_DIR = \
- ft_utils.get_functest_config('general.directories.dir_tempest_cases')
-TEMPEST_CUSTOM = REPO_PATH + TEST_LIST_DIR + 'test_list.txt'
-TEMPEST_BLACKLIST = REPO_PATH + TEST_LIST_DIR + 'blacklist.txt'
-TEMPEST_DEFCORE = REPO_PATH + TEST_LIST_DIR + 'defcore_req.txt'
-TEMPEST_RAW_LIST = TEMPEST_RESULTS_DIR + '/test_raw_list.txt'
-TEMPEST_LIST = TEMPEST_RESULTS_DIR + '/test_list.txt'
+TEMPEST_PRIVATE_NET_NAME = ft_constants.TEMPEST_PRIVATE_NET_NAME
+TEMPEST_PRIVATE_SUBNET_NAME = ft_constants.TEMPEST_PRIVATE_SUBNET_NAME
+TEMPEST_PRIVATE_SUBNET_CIDR = ft_constants.TEMPEST_PRIVATE_SUBNET_CIDR
+TEMPEST_ROUTER_NAME = ft_constants.TEMPEST_ROUTER_NAME
+TEMPEST_TENANT_NAME = ft_constants.TEMPEST_TENANT_NAME
+TEMPEST_TENANT_DESCRIPTION = ft_constants.TEMPEST_TENANT_DESCRIPTION
+TEMPEST_USER_NAME = ft_constants.TEMPEST_USER_NAME
+TEMPEST_USER_PASSWORD = ft_constants.TEMPEST_USER_PASSWORD
+TEMPEST_SSH_TIMEOUT = ft_constants.TEMPEST_SSH_TIMEOUT
+TEMPEST_USE_CUSTOM_IMAGES = ft_constants.TEMPEST_USE_CUSTOM_IMAGES
+TEMPEST_USE_CUSTOM_FLAVORS = ft_constants.TEMPEST_USE_CUSTOM_FLAVORS
+
+RESULTS_DIR = ft_constants.FUNCTEST_RESULTS_DIR
+TEMPEST_RESULTS_DIR = os.path.join(RESULTS_DIR, 'tempest')
+
+REPO_PATH = ft_constants.FUNCTEST_REPO_DIR
+TEMPEST_TEST_LIST_DIR = ft_constants.TEMPEST_TEST_LIST_DIR
+TEMPEST_CUSTOM = os.path.join(REPO_PATH, TEMPEST_TEST_LIST_DIR,
+ 'test_list.txt')
+TEMPEST_BLACKLIST = os.path.join(REPO_PATH, TEMPEST_TEST_LIST_DIR,
+ 'blacklist.txt')
+TEMPEST_DEFCORE = os.path.join(REPO_PATH, TEMPEST_TEST_LIST_DIR,
+ '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')
+
+
+class GlobalVariables:
+ IMAGE_ID = None
+ FLAVOR_ID = None
+ MODE = "smoke"
def get_info(file_result):
logger.debug("Creating tenant and user for Tempest suite")
tenant_id = os_utils.create_tenant(keystone_client,
- TENANT_NAME,
- TENANT_DESCRIPTION)
+ TEMPEST_TENANT_NAME,
+ TEMPEST_TENANT_DESCRIPTION)
if not tenant_id:
- logger.error("Error : Failed to create %s tenant" % TENANT_NAME)
+ logger.error("Error : Failed to create %s tenant"
+ % TEMPEST_TENANT_NAME)
- user_id = os_utils.create_user(keystone_client, USER_NAME, USER_PASSWORD,
+ user_id = os_utils.create_user(keystone_client, TEMPEST_USER_NAME,
+ TEMPEST_USER_PASSWORD,
None, tenant_id)
if not user_id:
- logger.error("Error : Failed to create %s user" % USER_NAME)
+ logger.error("Error : Failed to create %s user" % TEMPEST_USER_NAME)
logger.debug("Creating private network for Tempest suite")
- network_dic = os_utils.create_shared_network_full(PRIVATE_NET_NAME,
- PRIVATE_SUBNET_NAME,
- ROUTER_NAME,
- PRIVATE_SUBNET_CIDR)
+ network_dic = \
+ os_utils.create_shared_network_full(TEMPEST_PRIVATE_NET_NAME,
+ TEMPEST_PRIVATE_SUBNET_NAME,
+ TEMPEST_ROUTER_NAME,
+ TEMPEST_PRIVATE_SUBNET_CIDR)
if not network_dic:
exit(1)
- if USE_CUSTOM_IMAGES:
+ if TEMPEST_USE_CUSTOM_IMAGES:
# adding alternative image should be trivial should we need it
logger.debug("Creating image for Tempest suite")
- global IMAGE_ID
- _, IMAGE_ID = os_utils.get_or_create_image(GLANCE_IMAGE_NAME,
- GLANCE_IMAGE_PATH,
- GLANCE_IMAGE_FORMAT)
- if not IMAGE_ID:
+ _, GlobalVariables.IMAGE_ID = os_utils.get_or_create_image(
+ GLANCE_IMAGE_NAME, GLANCE_IMAGE_PATH, GLANCE_IMAGE_FORMAT)
+ if not GlobalVariables.IMAGE_ID:
exit(-1)
- if USE_CUSTOM_FLAVORS:
+ if TEMPEST_USE_CUSTOM_FLAVORS:
# adding alternative flavor should be trivial should we need it
logger.debug("Creating flavor for Tempest suite")
- global FLAVOR_ID
- _, FLAVOR_ID = os_utils.get_or_create_flavor(FLAVOR_NAME,
- FLAVOR_RAM,
- FLAVOR_DISK,
- FLAVOR_VCPUS)
- if not FLAVOR_ID:
+ _, GlobalVariables.FLAVOR_ID = os_utils.get_or_create_flavor(
+ FLAVOR_NAME, FLAVOR_RAM, FLAVOR_DISK, FLAVOR_VCPUS)
+ if not GlobalVariables.FLAVOR_ID:
exit(-1)
logger.debug("Updating selected tempest.conf parameters...")
config = ConfigParser.RawConfigParser()
config.read(tempest_conf_file)
- config.set('compute', 'fixed_network_name', PRIVATE_NET_NAME)
- if USE_CUSTOM_IMAGES:
- if IMAGE_ID is not None:
- config.set('compute', 'image_ref', IMAGE_ID)
+ config.set('compute', 'fixed_network_name', TEMPEST_PRIVATE_NET_NAME)
+ if TEMPEST_USE_CUSTOM_IMAGES:
+ if GlobalVariables.IMAGE_ID is not None:
+ config.set('compute', 'image_ref', GlobalVariables.IMAGE_ID)
if IMAGE_ID_ALT is not None:
config.set('compute', 'image_ref_alt', IMAGE_ID_ALT)
- if USE_CUSTOM_FLAVORS:
- if FLAVOR_ID is not None:
- config.set('compute', 'flavor_ref', FLAVOR_ID)
+ if TEMPEST_USE_CUSTOM_FLAVORS:
+ if GlobalVariables.FLAVOR_ID is not None:
+ config.set('compute', 'flavor_ref', GlobalVariables.FLAVOR_ID)
if FLAVOR_ID_ALT is not None:
config.set('compute', 'flavor_ref_alt', FLAVOR_ID_ALT)
- config.set('identity', 'tenant_name', TENANT_NAME)
- config.set('identity', 'username', USER_NAME)
- config.set('identity', 'password', USER_PASSWORD)
- config.set('validation', 'ssh_timeout', SSH_TIMEOUT)
+ config.set('identity', 'tenant_name', TEMPEST_TENANT_NAME)
+ config.set('identity', 'username', TEMPEST_USER_NAME)
+ config.set('identity', 'password', TEMPEST_USER_PASSWORD)
+ config.set('validation', 'ssh_timeout', TEMPEST_SSH_TIMEOUT)
- if os.getenv('OS_ENDPOINT_TYPE') is not None:
+ if ft_constants.OS_ENDPOINT_TYPE is not None:
services_list = ['compute', 'volume', 'image', 'network',
'data-processing', 'object-storage', 'orchestration']
sections = config.sections()
if service not in sections:
config.add_section(service)
config.set(service, 'endpoint_type',
- os.environ.get("OS_ENDPOINT_TYPE"))
+ ft_constants.OS_ENDPOINT_TYPE)
with open(tempest_conf_file, 'wb') as config_file:
config.write(config_file)
result_file = open(TEMPEST_LIST, 'w')
black_tests = []
try:
- installer_type = os.getenv('INSTALLER_TYPE')
- deploy_scenario = os.getenv('DEPLOY_SCENARIO')
+ installer_type = ft_constants.CI_INSTALLER_TYPE
+ deploy_scenario = ft_constants.CI_SCENARIO
if (bool(installer_type) * bool(deploy_scenario)):
# if INSTALLER_TYPE and DEPLOY_SCENARIO are set we read the file
black_list_file = open(TEMPEST_BLACKLIST)
header = ("Tempest environment:\n"
" Installer: %s\n Scenario: %s\n Node: %s\n Date: %s\n" %
- (os.getenv('INSTALLER_TYPE', 'Unknown'),
- os.getenv('DEPLOY_SCENARIO', 'Unknown'),
- os.getenv('NODE_NAME', 'Unknown'),
+ (ft_constants.CI_INSTALLER_TYPE,
+ ft_constants.CI_SCENARIO,
+ ft_constants.CI_NODE,
time.strftime("%a %b %d %H:%M:%S %Z %Y")))
f_stdout = open(TEMPEST_RESULTS_DIR + "/tempest.log", 'w+')
def main():
- global MODE
if not (args.mode in modes):
logger.error("Tempest mode not valid. "
create_tempest_resources()
if "" == args.conf:
- MODE = ""
+ GlobalVariables.MODE = ""
configure_tempest(deployment_dir)
else:
- MODE = " --tempest-config " + args.conf
+ GlobalVariables.MODE = " --tempest-config " + args.conf
generate_test_list(deployment_dir, args.mode)
apply_tempest_blacklist()
- MODE += " --tests-file " + TEMPEST_LIST
+ GlobalVariables.MODE += " --tests-file " + TEMPEST_LIST
if args.serial:
- MODE += " --concur 1"
+ GlobalVariables.MODE += " --concur 1"
- ret_val = run_tempest(MODE)
+ ret_val = run_tempest(GlobalVariables.MODE)
if ret_val != 0:
sys.exit(-1)
import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as functest_utils
-
+import functest.utils.functest_constants as ft_constants
parser = argparse.ArgumentParser()
parser.add_argument("-r", "--report",
action="store_true")
args = parser.parse_args()
-COPPER_REPO = \
- functest_utils.get_functest_config('general.directories.dir_repo_copper')
-RESULTS_DIR = \
- functest_utils.get_functest_config('general.directories.dir_results')
+COPPER_REPO_DIR = ft_constants.COPPER_REPO_DIR
+RESULTS_DIR = ft_constants.FUNCTEST_RESULTS_DIR
logger = ft_logger.Logger("copper").getLogger()
def main():
- cmd = "%s/tests/run.sh %s/tests" % (COPPER_REPO, COPPER_REPO)
+ cmd = "%s/tests/run.sh %s/tests" % (COPPER_REPO_DIR, COPPER_REPO_DIR)
start_time = time.time()
sys.exit(0)
+
if __name__ == '__main__':
main()
import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as functest_utils
-
+import functest.utils.functest_constants as ft_constants
parser = argparse.ArgumentParser()
parser.add_argument("-r", "--report",
functest_yaml = functest_utils.get_functest_yaml()
-DOCTOR_REPO = \
- functest_utils.get_functest_config('general.directories.dir_repo_doctor')
-RESULTS_DIR = \
- functest_utils.get_functest_config('general.directories.dir_results')
+DOCTOR_REPO_DIR = ft_constants.DOCTOR_REPO_DIR
+RESULTS_DIR = ft_constants.FUNCTEST_RESULTS_DIR
logger = ft_logger.Logger("doctor").getLogger()
if 'doctor' in functest_yaml and 'image_name' in functest_yaml['doctor']:
os.environ["IMAGE_NAME"] = functest_yaml['doctor']['image_name']
- cmd = 'cd %s/tests && ./run.sh' % DOCTOR_REPO
+ cmd = 'cd %s/tests && ./run.sh' % DOCTOR_REPO_DIR
log_file = RESULTS_DIR + "/doctor.log"
start_time = time.time()
exit(exit_code)
+
if __name__ == '__main__':
main()
from functest.core import TestCasesBase
import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as ft_utils
+import functest.utils.functest_constants as ft_constants
class DominoCases(TestCasesBase.TestCasesBase):
- DOMINO_REPO = \
- ft_utils.get_functest_config('general.directories.dir_repo_domino')
- RESULTS_DIR = \
- ft_utils.get_functest_config('general.directories.dir_results')
+ DOMINO_REPO = ft_constants.DOMINO_REPO
+ RESULTS_DIR = ft_constants.FUNCTEST_RESULTS_DIR
logger = ft_logger.Logger("domino").getLogger()
def __init__(self):
kwargs = {}
return self.main(**kwargs)
+
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument("-r", "--report",
def main():
logger.info("multisite OK")
+
if __name__ == '__main__':
main()
import keystoneclient.v2_0.client as ksclient
from neutronclient.v2_0 import client as ntclient
import novaclient.client as nvclient
-
+import functest.utils.functest_constants as ft_constants
parser = argparse.ArgumentParser()
args = parser.parse_args()
-dirs = ft_utils.get_functest_config('general.directories')
-PROMISE_REPO = dirs.get('dir_repo_promise')
-RESULTS_DIR = ft_utils.get_functest_config('general.directories.dir_results')
+PROMISE_REPO_DIR = ft_constants.PROMISE_REPO_DIR
+RESULTS_DIR = ft_constants.FUNCTEST_RESULTS_DIR
-TENANT_NAME = ft_utils.get_functest_config('promise.tenant_name')
-TENANT_DESCRIPTION = \
- ft_utils.get_functest_config('promise.tenant_description')
-USER_NAME = ft_utils.get_functest_config('promise.user_name')
-USER_PWD = ft_utils.get_functest_config('promise.user_pwd')
-IMAGE_NAME = ft_utils.get_functest_config('promise.image_name')
-FLAVOR_NAME = ft_utils.get_functest_config('promise.flavor_name')
-FLAVOR_VCPUS = ft_utils.get_functest_config('promise.flavor_vcpus')
-FLAVOR_RAM = ft_utils.get_functest_config('promise.flavor_ram')
-FLAVOR_DISK = ft_utils.get_functest_config('promise.flavor_disk')
+PROMISE_TENANT_NAME = ft_constants.PROMISE_TENANT_NAME
+TENANT_DESCRIPTION = ft_constants.TENANT_DESCRIPTION
+PROMISE_USER_NAME = ft_constants.PROMISE_USER_NAME
+PROMISE_USER_PWD = ft_constants.PROMISE_USER_PWD
+PROMISE_IMAGE_NAME = ft_constants.PROMISE_IMAGE_NAME
+PROMISE_FLAVOR_NAME = ft_constants.PROMISE_FLAVOR_NAME
+PROMISE_FLAVOR_VCPUS = ft_constants.PROMISE_FLAVOR_VCPUS
+PROMISE_FLAVOR_RAM = ft_constants.PROMISE_FLAVOR_RAM
+PROMISE_FLAVOR_DISK = ft_constants.PROMISE_FLAVOR_DISK
-GLANCE_IMAGE_FILENAME = \
- ft_utils.get_functest_config('general.openstack.image_file_name')
-GLANCE_IMAGE_FORMAT = \
- ft_utils.get_functest_config('general.openstack.image_disk_format')
-GLANCE_IMAGE_PATH = \
- ft_utils.get_functest_config('general.directories.dir_functest_data') + \
- "/" + GLANCE_IMAGE_FILENAME
+GLANCE_IMAGE_FILENAME = ft_constants.GLANCE_IMAGE_FILENAME
+GLANCE_IMAGE_FORMAT = ft_constants.GLANCE_IMAGE_FORMAT
+GLANCE_IMAGE_PATH = os.path.join(ft_constants.FUNCTEST_DATA_DIR,
+ GLANCE_IMAGE_FILENAME)
-NET_NAME = ft_utils.get_functest_config('promise.network_name')
-SUBNET_NAME = ft_utils.get_functest_config('promise.subnet_name')
-SUBNET_CIDR = ft_utils.get_functest_config('promise.subnet_cidr')
-ROUTER_NAME = ft_utils.get_functest_config('promise.router_name')
+PROMISE_NET_NAME = ft_constants.PROMISE_NET_NAME
+PROMISE_SUBNET_NAME = ft_constants.PROMISE_SUBNET_NAME
+PROMISE_SUBNET_CIDR = ft_constants.PROMISE_SUBNET_CIDR
+PROMISE_ROUTER_NAME = ft_constants.PROMISE_ROUTER_NAME
""" logging configuration """
ks_creds['username'])
exit(-1)
- logger.info("Creating tenant '%s'..." % TENANT_NAME)
+ logger.info("Creating tenant '%s'..." % PROMISE_TENANT_NAME)
tenant_id = openstack_utils.create_tenant(
- keystone, TENANT_NAME, TENANT_DESCRIPTION)
+ keystone, PROMISE_TENANT_NAME, TENANT_DESCRIPTION)
if not tenant_id:
- logger.error("Error : Failed to create %s tenant" % TENANT_NAME)
+ logger.error("Error : Failed to create %s tenant"
+ % PROMISE_TENANT_NAME)
exit(-1)
- logger.debug("Tenant '%s' created successfully." % TENANT_NAME)
+ logger.debug("Tenant '%s' created successfully." % PROMISE_TENANT_NAME)
roles_name = ["admin", "Admin"]
role_id = ''
logger.error("Error : Failed to get id for %s role" % role_name)
exit(-1)
- logger.info("Adding role '%s' to tenant '%s'..." % (role_id, TENANT_NAME))
+ logger.info("Adding role '%s' to tenant '%s'..."
+ % (role_id, PROMISE_TENANT_NAME))
if not openstack_utils.add_role_user(keystone, user_id,
role_id, tenant_id):
logger.error("Error : Failed to add %s on tenant %s" %
- (ks_creds['username'], TENANT_NAME))
+ (ks_creds['username'], PROMISE_TENANT_NAME))
exit(-1)
logger.debug("Role added successfully.")
- logger.info("Creating user '%s'..." % USER_NAME)
+ logger.info("Creating user '%s'..." % PROMISE_USER_NAME)
user_id = openstack_utils.create_user(
- keystone, USER_NAME, USER_PWD, None, tenant_id)
+ keystone, PROMISE_USER_NAME, PROMISE_USER_PWD, None, tenant_id)
if not user_id:
- logger.error("Error : Failed to create %s user" % USER_NAME)
+ logger.error("Error : Failed to create %s user" % PROMISE_USER_NAME)
exit(-1)
- logger.debug("User '%s' created successfully." % USER_NAME)
+ logger.debug("User '%s' created successfully." % PROMISE_USER_NAME)
logger.info("Updating OpenStack credentials...")
ks_creds.update({
- "username": TENANT_NAME,
- "password": TENANT_NAME,
- "tenant_name": TENANT_NAME,
+ "username": PROMISE_TENANT_NAME,
+ "password": PROMISE_TENANT_NAME,
+ "tenant_name": PROMISE_TENANT_NAME,
})
nt_creds.update({
- "tenant_name": TENANT_NAME,
+ "tenant_name": PROMISE_TENANT_NAME,
})
nv_creds.update({
- "project_id": TENANT_NAME,
+ "project_id": PROMISE_TENANT_NAME,
})
glance = openstack_utils.get_glance_client()
nova = nvclient.Client("2", **nv_creds)
- logger.info("Creating image '%s' from '%s'..." % (IMAGE_NAME,
+ logger.info("Creating image '%s' from '%s'..." % (PROMISE_IMAGE_NAME,
GLANCE_IMAGE_PATH))
image_id = openstack_utils.create_glance_image(glance,
- IMAGE_NAME,
+ PROMISE_IMAGE_NAME,
GLANCE_IMAGE_PATH)
if not image_id:
logger.error("Failed to create the Glance image...")
exit(-1)
- logger.debug("Image '%s' with ID '%s' created successfully." % (IMAGE_NAME,
- image_id))
- flavor_id = openstack_utils.get_flavor_id(nova, FLAVOR_NAME)
+ logger.debug("Image '%s' with ID '%s' created successfully."
+ % (PROMISE_IMAGE_NAME, image_id))
+ flavor_id = openstack_utils.get_flavor_id(nova, PROMISE_FLAVOR_NAME)
if flavor_id == '':
- logger.info("Creating flavor '%s'..." % FLAVOR_NAME)
+ logger.info("Creating flavor '%s'..." % PROMISE_FLAVOR_NAME)
flavor_id = openstack_utils.create_flavor(nova,
- FLAVOR_NAME,
- FLAVOR_RAM,
- FLAVOR_DISK,
- FLAVOR_VCPUS)
+ PROMISE_FLAVOR_NAME,
+ PROMISE_FLAVOR_RAM,
+ PROMISE_FLAVOR_DISK,
+ PROMISE_FLAVOR_VCPUS)
if not flavor_id:
logger.error("Failed to create the Flavor...")
exit(-1)
logger.debug("Flavor '%s' with ID '%s' created successfully." %
- (FLAVOR_NAME, flavor_id))
+ (PROMISE_FLAVOR_NAME, flavor_id))
else:
logger.debug("Using existing flavor '%s' with ID '%s'..."
- % (FLAVOR_NAME, flavor_id))
+ % (PROMISE_FLAVOR_NAME, flavor_id))
neutron = ntclient.Client(**nt_creds)
network_dic = openstack_utils.create_network_full(neutron,
- NET_NAME,
- SUBNET_NAME,
- ROUTER_NAME,
- SUBNET_CIDR)
+ PROMISE_NET_NAME,
+ PROMISE_SUBNET_NAME,
+ PROMISE_ROUTER_NAME,
+ PROMISE_SUBNET_CIDR)
if not network_dic:
logger.error("Failed to create the private network...")
exit(-1)
logger.info("Exporting environment variables...")
os.environ["NODE_ENV"] = "functest"
- os.environ["OS_TENANT_NAME"] = TENANT_NAME
- os.environ["OS_USERNAME"] = USER_NAME
- os.environ["OS_PASSWORD"] = USER_PWD
+ os.environ["OS_PASSWORD"] = PROMISE_USER_PWD
os.environ["OS_TEST_IMAGE"] = image_id
os.environ["OS_TEST_FLAVOR"] = flavor_id
os.environ["OS_TEST_NETWORK"] = network_dic["net_id"]
+ os.environ["OS_TENANT_NAME"] = PROMISE_TENANT_NAME
+ os.environ["OS_USERNAME"] = PROMISE_USER_NAME
- os.chdir(PROMISE_REPO + '/source/')
- results_file_name = RESULTS_DIR + '/' + 'promise-results.json'
+ os.chdir(PROMISE_REPO_DIR + '/source/')
+ results_file_name = os.path.join(RESULTS_DIR, 'promise-results.json')
results_file = open(results_file_name, 'w+')
cmd = 'npm run -s test -- --reporter json'
import paramiko
import functest.utils.functest_logger as ft_logger
+import functest.utils.functest_constants as ft_constants
# add installer IP from env
-INSTALLER_IP = os.getenv('INSTALLER_IP')
+INSTALLER_IP = ft_constants.CI_INSTALLER_IP
# Set up loggers
logger = ft_logger.Logger("security_scan").getLogger()
return True
except:
return False
+
+
print is_connected()
from novaclient import client
import connect
-import functest.utils.functest_utils as ft_utils
+import functest.utils.functest_constants as ft_constants
__version__ = 0.1
__author__ = 'Luke Hinds (lhinds@redhat.com)'
__url__ = 'https://wiki.opnfv.org/display/functest/Functest+Security'
# Global vars
-INSTALLER_IP = os.getenv('INSTALLER_IP')
+INSTALLER_IP = ft_constants.CI_INSTALLER_IP
oscapbin = 'sudo /bin/oscap'
-functest_dir = '%s/opnfv_tests/security_scan/' % ft_utils.FUNCTEST_REPO
+functest_dir = '%s/security_scan/' % ft_constants.FUNCTEST_TEST_DIR
# Apex Spefic var needed to query Undercloud
-if os.getenv('OS_AUTH_URL') is None:
+if ft_constants.OS_AUTH_URL is None:
connect.logger.error(" Enviroment variable OS_AUTH_URL is not set")
sys.exit(0)
else:
- OS_AUTH_URL = os.getenv('OS_AUTH_URL')
+ OS_AUTH_URL = ft_constants.OS_AUTH_URL
# args
parser = argparse.ArgumentParser(description='OPNFV OpenSCAP Scanner')
nova = client.Client(2, session=sess)
+class GlobalVariables:
+ tmpdir = ""
+
+
def run_tests(host, nodetype):
user = cfgparse.get(nodetype, 'user')
port = cfgparse.get(nodetype, 'port')
def createfiles(host, port, user, localkey):
import connect
- global tmpdir
localpath = functest_dir + 'scripts/createfiles.py'
remotepath = '/tmp/createfiles.py'
com = 'python /tmp/createfiles.py'
connect = connect.ConnectionManager(host, port, user, localkey,
localpath, remotepath, com)
- tmpdir = connect.remotescript()
+ GlobalVariables.tmpdir = connect.remotescript()
def install_pkg(host, port, user, localkey):
if scantype == 'xccdf':
cpe = cfgparse.get(nodetype, 'cpe')
com = '{0} xccdf eval --profile {1} --results {2}/{3}' \
- ' --report {2}/{4} --cpe {5} {6}'.format(oscapbin,
- profile,
- tmpdir.rstrip(),
- results,
- report,
- cpe,
- secpolicy)
+ ' --report {2}/{4}' \
+ ' --cpe {5} {6}'.format(oscapbin,
+ profile,
+ GlobalVariables.tmpdir.rstrip(),
+ results,
+ report,
+ cpe,
+ secpolicy)
connect = connect.ConnectionManager(host, port, user, localkey, com)
connect.remotecmd()
elif scantype == 'oval':
com = '{0} oval eval --results {1}/{2} '
- '--report {1}/{3} {4}'.format(oscapbin, tmpdir.rstrip(),
+ '--report {1}/{3} {4}'.format(oscapbin,
+ GlobalVariables.tmpdir.rstrip(),
results, report, secpolicy)
connect = connect.ConnectionManager(host, port, user, localkey, com)
connect.remotecmd()
os.makedirs(dl_folder, 0755)
report = cfgparse.get(nodetype, 'report')
results = cfgparse.get(nodetype, 'results')
- reportfile = '{0}/{1}'.format(tmpdir.rstrip(), report)
+ reportfile = '{0}/{1}'.format(GlobalVariables.tmpdir.rstrip(), report)
connect = connect.ConnectionManager(host, port, user, localkey, dl_folder,
reportfile, report, results)
connect.download_reports()
def cleandir(host, port, user, localkey, nodetype):
import connect
- com = 'sudo rm -r {0}'.format(tmpdir.rstrip())
+ com = 'sudo rm -r {0}'.format(GlobalVariables.tmpdir.rstrip())
connect = connect.ConnectionManager(host, port, user, localkey, com)
connect.remotecmd()
import functest.utils.openstack_utils as os_utils
from clearwater import clearwater
from orchestrator import orchestrator
+import functest.utils.functest_constants as ft_constants
pp = pprint.PrettyPrinter(indent=4)
# Cloudify parameters
-VIMS_DIR = ft_utils.FUNCTEST_REPO + '/' + \
- ft_utils.get_functest_config('general.directories.dir_vIMS')
-
-VIMS_DATA_DIR = \
- ft_utils.get_functest_config('general.directories.dir_vIMS_data') + \
- '/'
-VIMS_TEST_DIR = \
- ft_utils.get_functest_config('general.directories.dir_repo_vims_test') + \
- '/'
-DB_URL = \
- ft_utils.get_functest_config('results.test_db_url')
-
-TENANT_NAME = \
- ft_utils.get_functest_config('vIMS.general.tenant_name')
-TENANT_DESCRIPTION = \
- ft_utils.get_functest_config('vIMS.general.tenant_description')
-IMAGES = \
- ft_utils.get_functest_config('vIMS.general.images')
-
-CFY_MANAGER_BLUEPRINT = \
- ft_utils.get_functest_config('vIMS.cloudify.blueprint')
-CFY_MANAGER_REQUIERMENTS = \
- ft_utils.get_functest_config('vIMS.cloudify.requierments')
-CFY_INPUTS = ft_utils.get_functest_config('vIMS.cloudify.inputs')
-
-CW_BLUEPRINT = \
- ft_utils.get_functest_config('vIMS.clearwater.blueprint')
-CW_DEPLOYMENT_NAME = \
- ft_utils.get_functest_config('vIMS.clearwater.deployment-name')
-CW_INPUTS = \
- ft_utils.get_functest_config('vIMS.clearwater.inputs')
-CW_REQUIERMENTS = \
- ft_utils.get_functest_config('vIMS.clearwater.requierments')
+VIMS_DIR = os.path.join(ft_constants.FUNCTEST_TEST_DIR, 'vnf/vIMS/')
+VIMS_DATA_DIR = ft_constants.VIMS_DATA_DIR
+VIMS_TEST_DIR = ft_constants.VIMS_TEST_DIR
+VIMS_TENANT_NAME = ft_constants.VIMS_TENANT_NAME
+VIMS_TENANT_DESCRIPTION = ft_constants.VIMS_TENANT_DESCRIPTION
+VIMS_IMAGES = ft_constants.VIMS_IMAGES
+
+CFY_MANAGER_BLUEPRINT = ft_constants.CFY_MANAGER_BLUEPRINT
+CFY_MANAGER_REQUIERMENTS = ft_constants.CFY_MANAGER_REQUIERMENTS
+CFY_INPUTS = ft_constants.CFY_INPUTS
+
+CW_BLUEPRINT = ft_constants.CW_BLUEPRINT
+CW_DEPLOYMENT_NAME = ft_constants.CW_DEPLOYMENT_NAME
+CW_INPUTS = ft_constants.CW_INPUTS
+CW_REQUIERMENTS = ft_constants.CW_REQUIERMENTS
CFY_DEPLOYMENT_DURATION = 0
CW_DEPLOYMENT_DURATION = 0
def download_and_add_image_on_glance(glance, image_name, image_url):
- dest_path = VIMS_DATA_DIR + "tmp/"
+ dest_path = os.path.join(VIMS_DATA_DIR, "tmp/")
if not os.path.exists(dest_path):
os.makedirs(dest_path)
file_name = image_url.rsplit('/')[-1]
logger.debug(result)
vims_test_result = ""
+ tempFile = os.path.join(VIMS_TEST_DIR, "temp.json")
try:
logger.debug("Trying to load test results")
- with open(VIMS_TEST_DIR + "temp.json") as f:
+ with open(tempFile) as f:
vims_test_result = json.load(f)
f.close()
except:
RESULTS)
try:
- os.remove(VIMS_TEST_DIR + "temp.json")
+ os.remove(tempFile)
except:
logger.error("Deleting file failed")
ks_creds['username'])
tenant_id = os_utils.create_tenant(
- keystone, TENANT_NAME, TENANT_DESCRIPTION)
+ keystone, VIMS_TENANT_NAME, VIMS_TENANT_DESCRIPTION)
if not tenant_id:
step_failure("init", "Error : Failed to create " +
- TENANT_NAME + " tenant")
+ VIMS_TENANT_NAME + " tenant")
roles_name = ["admin", "Admin"]
role_id = ''
ks_creds['username'])
user_id = os_utils.create_user(
- keystone, TENANT_NAME, TENANT_NAME, None, tenant_id)
+ keystone, VIMS_TENANT_NAME, VIMS_TENANT_NAME, None, tenant_id)
if not user_id:
- logger.error("Error : Failed to create %s user" % TENANT_NAME)
+ logger.error("Error : Failed to create %s user" % VIMS_TENANT_NAME)
logger.info("Update OpenStack creds informations")
ks_creds.update({
- "username": TENANT_NAME,
- "password": TENANT_NAME,
- "tenant_name": TENANT_NAME,
+ "username": VIMS_TENANT_NAME,
+ "password": VIMS_TENANT_NAME,
+ "tenant_name": VIMS_TENANT_NAME,
})
nt_creds.update({
- "tenant_name": TENANT_NAME,
+ "tenant_name": VIMS_TENANT_NAME,
})
nv_creds.update({
- "project_id": TENANT_NAME,
+ "project_id": VIMS_TENANT_NAME,
})
logger.info("Upload some OS images if it doesn't exist")
glance = os_utils.get_glance_client()
- for img in IMAGES.keys():
- image_name = IMAGES[img]['image_name']
- image_url = IMAGES[img]['image_url']
+ for img in VIMS_IMAGES.keys():
+ image_name = VIMS_IMAGES[img]['image_name']
+ image_url = VIMS_IMAGES[img]['image_url']
image_id = os_utils.get_image_id(glance, image_name)
if not os_utils.update_sg_quota(neutron, tenant_id, 50, 100):
step_failure(
"init",
- "Failed to update security group quota for tenant " + TENANT_NAME)
+ "Failed to update security group quota for tenant " +
+ VIMS_TENANT_NAME)
# ############### CLOUDIFY INITIALISATION ################
public_auth_url = keystone.service_catalog.url_for(
import functest.utils.functest_logger as ft_logger
import functest.utils.functest_utils as functest_utils
-
+import functest.utils.functest_constants as ft_constants
parser = argparse.ArgumentParser()
parser.add_argument("-r", "--report",
action="store_true")
args = parser.parse_args()
-PARSER_REPO = \
- functest_utils.get_functest_config('general.directories.dir_repo_parser')
-RESULTS_DIR = \
- functest_utils.get_functest_config('general.directories.dir_results')
+PARSER_REPO = ft_constants.PARSER_REPO
+RESULTS_DIR = ft_constants.FUNCTEST_RESULTS_DIR
logger = ft_logger.Logger("parser").getLogger()
details)
exit(ret)
+
if __name__ == '__main__':
main()
self.test.start_time = "1"
self.test.stop_time = "2"
self.test.criteria = "100"
- self.test.details = {"Hello": "World"}
+ self.test.details = {"Hello": "World"}
def test_run_unimplemented(self):
self.assertEqual(self.test.run(),
from functest.core import TestCasesBase
from functest.opnfv_tests.Controllers.ODL import OpenDaylightTesting
+from functest.utils import functest_constants as ft_constants
class ODLTestCasesTesting(unittest.TestCase):
_odl_password = "admin"
def setUp(self):
- for var in ("INSTALLER_TYPE", "SDN_CONTROLLER", "SDN_CONTROLLER_IP"):
- if var in os.environ:
- del os.environ[var]
- os.environ["OS_USERNAME"] = self._os_username
- os.environ["OS_PASSWORD"] = self._os_password
- os.environ["OS_TENANT_NAME"] = self._os_tenantname
+ ft_constants.OS_USERNAME = self._os_username
+ ft_constants.OS_PASSWORD = self._os_password
+ ft_constants.OS_TENANT_NAME = self._os_tenantname
self.test = OpenDaylightTesting.ODLTestCases()
@mock.patch('fileinput.input', side_effect=Exception())
def _test_main(self, status, *args):
kwargs = self._get_main_kwargs()
self.assertEqual(self.test.main(**kwargs), status)
+ odl_res_dir = OpenDaylightTesting.ODLTestCases.res_dir
if len(args) > 0:
- args[0].assert_called_once_with(
- OpenDaylightTesting.ODLTestCases.res_dir)
+ args[0].assert_called_once_with(odl_res_dir)
if len(args) > 1:
variable = ['KEYSTONE:{}'.format(self._keystone_ip),
'NEUTRON:{}'.format(self._neutron_ip),
'ODL_SYSTEM_IP:{}'.format(self._sdn_controller_ip),
'PORT:{}'.format(self._odl_webport),
'RESTCONFPORT:{}'.format(self._odl_restconfport)]
+ output_file = os.path.join(odl_res_dir, 'output.xml')
args[1].assert_called_once_with(
OpenDaylightTesting.ODLTestCases.basic_suite_dir,
OpenDaylightTesting.ODLTestCases.neutron_suite_dir,
log='NONE',
- output=OpenDaylightTesting.ODLTestCases.res_dir + 'output.xml',
+ output=output_file,
report='NONE',
stdout=mock.ANY,
variable=variable)
if len(args) > 2:
- args[2].assert_called_with(
- OpenDaylightTesting.ODLTestCases.res_dir + 'stdout.txt')
+ stdout_file = os.path.join(odl_res_dir, 'stdout.txt')
+ args[2].assert_called_with(stdout_file)
def _test_main_missing_keyword(self, key):
kwargs = self._get_main_kwargs(key)
self._test_main(TestCasesBase.TestCasesBase.EX_OK, *args)
def _test_run_missing_env_var(self, var):
- del os.environ[var]
+ if var == 'OS_USERNAME':
+ ft_constants.OS_USERNAME = None
+ elif var == 'OS_PASSWORD':
+ ft_constants.OS_PASSWORD = None
+ elif var == 'OS_TENANT_NAME':
+ ft_constants.OS_TENANT_NAME = None
+
self.assertEqual(self.test.run(),
TestCasesBase.TestCasesBase.EX_RUN_ERROR)
self._test_run_missing_env_var("OS_TENANT_NAME")
def test_run_main_false(self):
- os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
+ ft_constants.CI_INSTALLER_TYPE = None
+ ft_constants.SDN_CONTROLLER_IP = self._sdn_controller_ip
self._test_run(TestCasesBase.TestCasesBase.EX_RUN_ERROR,
odlip=self._sdn_controller_ip,
odlwebport=self._odl_webport)
def test_run_main_exception(self):
- os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
+ ft_constants.CI_INSTALLER_TYPE = None
+ ft_constants.SDN_CONTROLLER_IP = self._sdn_controller_ip
with self.assertRaises(Exception):
self._test_run(status=TestCasesBase.TestCasesBase.EX_RUN_ERROR,
exception=Exception(),
def test_run_missing_sdn_controller_ip(self):
with mock.patch('functest.utils.openstack_utils.get_keystone_client',
return_value=self._get_fake_keystone_client()):
+ ft_constants.CI_INSTALLER_TYPE = None
+ ft_constants.SDN_CONTROLLER_IP = None
self.assertEqual(self.test.run(),
TestCasesBase.TestCasesBase.EX_RUN_ERROR)
def test_run_without_installer_type(self):
- os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
+ ft_constants.SDN_CONTROLLER_IP = self._sdn_controller_ip
+ ft_constants.CI_INSTALLER_TYPE = None
self._test_run(TestCasesBase.TestCasesBase.EX_OK,
odlip=self._sdn_controller_ip,
odlwebport=self._odl_webport)
def test_run_fuel(self):
- os.environ["INSTALLER_TYPE"] = "fuel"
+ ft_constants.CI_INSTALLER_TYPE = "fuel"
self._test_run(TestCasesBase.TestCasesBase.EX_OK,
odlip=self._neutron_ip, odlwebport='8282')
def test_run_apex_missing_sdn_controller_ip(self):
with mock.patch('functest.utils.openstack_utils.get_keystone_client',
return_value=self._get_fake_keystone_client()):
- os.environ["INSTALLER_TYPE"] = "apex"
+ ft_constants.CI_INSTALLER_TYPE = "apex"
+ ft_constants.SDN_CONTROLLER_IP = None
self.assertEqual(self.test.run(),
TestCasesBase.TestCasesBase.EX_RUN_ERROR)
def test_run_apex(self):
- os.environ["SDN_CONTROLLER_IP"] = self._sdn_controller_ip
- os.environ["INSTALLER_TYPE"] = "apex"
+ ft_constants.SDN_CONTROLLER_IP = self._sdn_controller_ip
+ ft_constants.CI_INSTALLER_TYPE = "apex"
self._test_run(TestCasesBase.TestCasesBase.EX_OK,
odlip=self._sdn_controller_ip, odlwebport='8181')
def test_run_joid_missing_sdn_controller(self):
with mock.patch('functest.utils.openstack_utils.get_keystone_client',
return_value=self._get_fake_keystone_client()):
- os.environ["INSTALLER_TYPE"] = "joid"
+ ft_constants.CI_INSTALLER_TYPE = "joid"
+ ft_constants.SDN_CONTROLLER = None
self.assertEqual(self.test.run(),
TestCasesBase.TestCasesBase.EX_RUN_ERROR)
def test_run_joid(self):
- os.environ["SDN_CONTROLLER"] = self._sdn_controller_ip
- os.environ["INSTALLER_TYPE"] = "joid"
+ ft_constants.SDN_CONTROLLER = self._sdn_controller_ip
+ ft_constants.CI_INSTALLER_TYPE = "joid"
self._test_run(TestCasesBase.TestCasesBase.EX_OK,
odlip=self._sdn_controller_ip,
odlwebport=self._odl_webport)
def test_run_compass(self, *args):
- os.environ["INSTALLER_TYPE"] = "compass"
+ ft_constants.CI_INSTALLER_TYPE = "compass"
self._test_run(TestCasesBase.TestCasesBase.EX_OK,
odlip=self._neutron_ip, odlwebport='8181')
# TODO
# ...
+
if __name__ == "__main__":
unittest.main(verbosity=2)
--- /dev/null
+#!/usr/bin/env python
+#
+# yaohelan@huawei.com
+# 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
+#
+import os
+import functest.utils.functest_utils as ft_utils
+import functest.utils.functest_logger as ft_logger
+
+logger = ft_logger.Logger("functest_constants").getLogger()
+
+
+""" global variables """
+INSTALLERS = ['fuel', 'compass', 'apex', 'joid']
+CI_INSTALLER_TYPE = os.getenv('INSTALLER_TYPE')
+CI_INSTALLER_IP = os.getenv('INSTALLER_IP')
+CI_SCENARIO = os.getenv('DEPLOY_SCENARIO')
+CI_NODE = os.getenv('NODE_NAME')
+CI_BUILD_TAG = os.getenv('BUILD_TAG')
+CI_DEBUG = os.getenv('CI_DEBUG')
+CI_LOOP = os.getenv('CI_LOOP')
+OS_AUTH_URL = os.getenv('OS_AUTH_URL')
+OS_USERNAME = os.getenv('OS_USERNAME')
+OS_TENANT_NAME = os.getenv('OS_TENANT_NAME')
+OS_PASSWORD = os.getenv('OS_PASSWORD')
+OS_ENDPOINT_TYPE = os.getenv('OS_ENDPOINT_TYPE')
+OS_REGION_NAME = os.getenv('OS_REGION_NAME')
+OS_CACERT = os.getenv('OS_CACERT')
+FUEL_ENV = os.getenv('FUEL_ENV')
+SDN_CONTROLLER_IP = os.getenv('SDN_CONTROLLER_IP')
+SDN_CONTROLLER = os.getenv('SDN_CONTROLLER')
+
+if CI_BUILD_TAG is not None:
+ IS_CI_RUN = True
+else:
+ IS_CI_RUN = False
+
+CONFIG_FUNCTEST_YAML = os.getenv("CONFIG_FUNCTEST_YAML")
+
+
+def get_value(functest_config_key, env_variable):
+ try:
+ constant = ft_utils.get_functest_config(functest_config_key)
+ # logger.debug("%s is defined in config_functest.yaml as [%s]"
+ # % (env_variable, constant))
+ return constant
+ except ValueError:
+ logger.warning("%s is not defined in config_functest.yaml"
+ % functest_config_key)
+ constant = os.getenv(env_variable)
+ if constant is None:
+ raise ValueError("%s is neither defined in config_functest.yaml"
+ " nor environment variable" % env_variable)
+ else:
+ logger.debug("%s is defined as environment variable as [%s]"
+ % (env_variable, constant))
+ return constant
+
+
+HOME = \
+ get_value('general.directories.dir_home', 'HOME')
+REPOS_DIR = \
+ get_value('general.directories.dir_repos', 'REPOS_DIR')
+FUNCTEST_BASE_DIR = \
+ get_value('general.directories.dir_functest', 'FUNCTEST_BASE_DIR')
+FUNCTEST_REPO_DIR = \
+ get_value('general.directories.dir_repo_functest', 'FUNCTEST_REPO_DIR')
+FUNCTEST_TEST_DIR = \
+ get_value('general.directories.dir_functest_test', 'FUNCTEST_TEST_DIR')
+FUNCTEST_CONF_DIR = \
+ get_value('general.directories.dir_functest_conf', 'FUNCTEST_CONF_DIR')
+FUNCTEST_DATA_DIR = \
+ get_value('general.directories.dir_functest_data', 'FUNCTEST_DATA_DIR')
+FUNCTEST_RESULTS_DIR = \
+ get_value('general.directories.dir_results', 'FUNCTEST_RESULTS_DIR')
+FUNCTEST_TESTCASES_YAML = \
+ get_value('general.functest.testcases_yaml', 'FUNCTEST_TESTCASES_YAML')
+RALLY_DEPLOYMENT_NAME = \
+ get_value('rally.deployment_name', 'RALLY_DEPLOYMENT_NAME')
+TEMPEST_REPO_DIR = \
+ get_value('general.directories.dir_repo_tempest', 'TEMPEST_REPO_DIR')
+
+ENV_FILE = os.path.join(FUNCTEST_CONF_DIR, "env_active")
+
+OPENSTACK_CREDS = \
+ get_value('general.openstack.creds', 'creds')
+OPENSTACK_SNAPSHOT_FILE = \
+ get_value('general.openstack.snapshot_file', 'OPENSTACK_SNAPSHOT_FILE')
+
+DOMINO_REPO = \
+ get_value('general.directories.dir_repo_domino', 'DOMINO_REPO')
+SDNVPN_REPO = \
+ get_value('general.directories.dir_repo_sdnvpn', 'SDNVPN_REPO')
+SFC_REPO = \
+ get_value('general.directories.dir_repo_sfc', 'SFC_REPO')
+
+ONOS_SFC_IMAGE_NAME = \
+ get_value('onos_sfc.image_name', 'ONOS_SFC_IMAGE_NAME')
+ONOS_SFC_IMAGE_FILENAME = \
+ get_value('onos_sfc.image_file_name', 'ONOS_SFC_IMAGE_FILENAME')
+ONOS_SFC_RELATIVE_PATH = \
+ get_value('general.directories.dir_onos_sfc', 'ONOS_SFC_RELATIVE_PATH')
+ONOS_SFC_IMAGE_BASE_URL = \
+ get_value('onos_sfc.image_base_url', 'ONOS_SFC_IMAGE_BASE_URL')
+RALLY_RELATIVE_PATH = \
+ get_value('general.directories.dir_rally', 'RALLY_RELATIVE_PATH')
+RALLY_PRIVATE_NET_NAME = \
+ get_value('rally.network_name', 'RALLY_PRIVATE_NET_NAME')
+RALLY_PRIVATE_SUBNET_NAME = \
+ get_value('rally.subnet_name', 'RALLY_PRIVATE_SUBNET_NAME')
+RALLY_PRIVATE_SUBNET_CIDR = \
+ get_value('rally.subnet_cidr', 'RALLY_PRIVATE_SUBNET_CIDR')
+RALLY_ROUTER_NAME = \
+ get_value('rally.router_name', 'RALLY_ROUTER_NAME')
+RALLY_INSTALLATION_DIR = \
+ get_value('general.directories.dir_rally_inst', 'RALLY_INSTALLATION_DIR')
+GLANCE_IMAGE_NAME = \
+ get_value('general.openstack.image_name', 'GLANCE_IMAGE_NAME')
+GLANCE_IMAGE_FILENAME = \
+ get_value('general.openstack.image_file_name', 'GLANCE_IMAGE_FILENAME')
+GLANCE_IMAGE_FORMAT = \
+ get_value('general.openstack.image_disk_format', 'GLANCE_IMAGE_FORMAT')
+FLAVOR_NAME = \
+ get_value('general.openstack.flavor_name', 'FLAVOR_NAME')
+FLAVOR_RAM = \
+ get_value('general.openstack.flavor_ram', 'FLAVOR_RAM')
+FLAVOR_DISK = \
+ get_value('general.openstack.flavor_disk', 'FLAVOR_DISK')
+FLAVOR_VCPUS = \
+ get_value('general.openstack.flavor_vcpus', 'FLAVOR_VCPUS')
+TEMPEST_PRIVATE_NET_NAME = \
+ get_value('tempest.private_net_name', 'TEMPEST_PRIVATE_NET_NAME')
+TEMPEST_PRIVATE_SUBNET_NAME = \
+ get_value('tempest.private_subnet_name', 'TEMPEST_PRIVATE_SUBNET_NAME')
+TEMPEST_PRIVATE_SUBNET_CIDR = \
+ get_value('tempest.private_subnet_cidr', 'TEMPEST_PRIVATE_SUBNET_CIDR')
+TEMPEST_ROUTER_NAME = \
+ get_value('tempest.router_name', 'TEMPEST_ROUTER_NAME')
+TEMPEST_TENANT_NAME = \
+ get_value('tempest.identity.tenant_name', 'TEMPEST_TENANT_NAME')
+TEMPEST_TENANT_DESCRIPTION = \
+ get_value('tempest.identity.tenant_description',
+ 'TEMPEST_TENANT_DESCRIPTION')
+TEMPEST_USER_NAME = \
+ get_value('tempest.identity.user_name', 'TEMPEST_USER_NAME')
+TEMPEST_USER_PASSWORD = \
+ get_value('tempest.identity.user_password', 'TEMPEST_USER_PASSWORD')
+TEMPEST_SSH_TIMEOUT = \
+ get_value('tempest.validation.ssh_timeout', 'TEMPEST_SSH_TIMEOUT')
+TEMPEST_USE_CUSTOM_IMAGES = \
+ get_value('tempest.use_custom_images', 'TEMPEST_USE_CUSTOM_IMAGES')
+TEMPEST_USE_CUSTOM_FLAVORS = \
+ get_value('tempest.use_custom_flavors', 'TEMPEST_USE_CUSTOM_FLAVORS')
+TEMPEST_TEST_LIST_DIR = \
+ get_value('general.directories.dir_tempest_cases', 'TEMPEST_TEST_LIST_DIR')
+NAME_VM_1 = \
+ get_value('vping.vm_name_1', 'NAME_VM_1')
+NAME_VM_2 = \
+ get_value('vping.vm_name_2', 'NAME_VM_2')
+PING_TIMEOUT = \
+ get_value('vping.ping_timeout', 'PING_TIMEOUT')
+VPING__IMAGE_NAME = \
+ get_value('vping.image_name', 'VPING__IMAGE_NAME')
+VPING_VM_FLAVOR = \
+ get_value('vping.vm_flavor', 'VPING_VM_FLAVOR')
+VPING_PRIVATE_NET_NAME = \
+ get_value('vping.vping_private_net_name', 'VPING_PRIVATE_NET_NAME')
+VPING_PRIVATE_SUBNET_NAME = \
+ get_value('vping.vping_private_subnet_name', 'VPING_PRIVATE_SUBNET_NAME')
+VPING_PRIVATE_SUBNET_CIDR = \
+ get_value('vping.vping_private_subnet_cidr', 'VPING_PRIVATE_SUBNET_CIDR')
+VPING_ROUTER_NAME = \
+ get_value('vping.vping_router_name', 'VPING_ROUTER_NAME')
+VPING_SECGROUP_NAME = \
+ get_value('vping.vping_sg_name', 'VPING_SECGROUP_NAME')
+VPING_SECGROUP_DESCR = \
+ get_value('vping.vping_sg_descr', 'VPING_SECGROUP_DESCR')
+ONOSBENCH_USERNAME = \
+ get_value('ONOS.general.onosbench_username', 'ONOSBENCH_USERNAME')
+ONOSBENCH_PASSWORD = \
+ get_value('ONOS.general.onosbench_password', 'ONOSBENCH_PASSWORD')
+ONOSCLI_USERNAME = \
+ get_value('ONOS.general.onoscli_username', 'ONOSCLI_USERNAME')
+ONOSCLI_PASSWORD = \
+ get_value('ONOS.general.onoscli_password', 'ONOSCLI_PASSWORD')
+ONOS_RUNTIMEOUT = \
+ get_value('ONOS.general.runtimeout', 'ONOS_RUNTIMEOUT')
+ONOS_OCT = \
+ get_value('ONOS.environment.OCT', 'ONOS_OCT')
+ONOS_OC1 = \
+ get_value('ONOS.environment.OC1', 'ONOS_OC1')
+ONOS_OC2 = \
+ get_value('ONOS.environment.OC2', 'ONOS_OC2')
+ONOS_OC3 = \
+ get_value('ONOS.environment.OC3', 'ONOS_OC3')
+ONOS_OCN = \
+ get_value('ONOS.environment.OCN', 'ONOS_OCN')
+ONOS_OCN2 = \
+ get_value('ONOS.environment.OCN2', 'ONOS_OCN2')
+ONOS_INSTALLER_MASTER = \
+ get_value('ONOS.environment.installer_master', 'ONOS_INSTALLER_MASTER')
+ONOS_INSTALLER_MASTER_USERNAME = \
+ get_value('ONOS.environment.installer_master_username',
+ 'ONOS_INSTALLER_MASTER_USERNAME')
+ONOS_INSTALLER_MASTER_PASSWORD = \
+ get_value('ONOS.environment.installer_master_password',
+ 'ONOS_INSTALLER_MASTER_PASSWORD')
+PROMISE_REPO_DIR = \
+ get_value('general.directories.dir_repo_promise', 'PROMISE_REPO_DIR')
+PROMISE_TENANT_NAME = \
+ get_value('promise.tenant_name', 'PROMISE_TENANT_NAME')
+TENANT_DESCRIPTION = \
+ get_value('promise.tenant_description', 'TENANT_DESCRIPTION')
+PROMISE_USER_NAME = \
+ get_value('promise.user_name', 'PROMISE_USER_NAME')
+PROMISE_USER_PWD = \
+ get_value('promise.user_pwd', 'PROMISE_USER_PWD')
+PROMISE_IMAGE_NAME = \
+ get_value('promise.image_name', 'PROMISE_IMAGE_NAME')
+PROMISE_FLAVOR_NAME = \
+ get_value('promise.flavor_name', 'PROMISE_FLAVOR_NAME')
+PROMISE_FLAVOR_VCPUS = \
+ get_value('promise.flavor_vcpus', 'PROMISE_FLAVOR_VCPUS')
+PROMISE_FLAVOR_RAM = \
+ get_value('promise.flavor_ram', 'PROMISE_FLAVOR_RAM')
+PROMISE_FLAVOR_DISK = \
+ get_value('promise.flavor_disk', 'PROMISE_FLAVOR_DISK')
+PROMISE_NET_NAME = \
+ get_value('promise.network_name', 'PROMISE_NET_NAME')
+PROMISE_SUBNET_NAME = \
+ get_value('promise.subnet_name', 'PROMISE_SUBNET_NAME')
+PROMISE_SUBNET_CIDR = \
+ get_value('promise.subnet_cidr', 'PROMISE_SUBNET_CIDR')
+PROMISE_ROUTER_NAME = \
+ get_value('promise.router_name', 'PROMISE_ROUTER_NAME')
+DOCTOR_REPO_DIR = \
+ get_value('general.directories.dir_repo_doctor', 'DOCTOR_REPO_DIR')
+COPPER_REPO_DIR = \
+ get_value('general.directories.dir_repo_copper', 'COPPER_REPO_DIR')
+EXAMPLE_INSTANCE_NAME = \
+ get_value('example.example_vm_name', 'EXAMPLE_INSTANCE_NAME')
+EXAMPLE_FLAVOR = \
+ get_value('example.example_flavor', 'EXAMPLE_FLAVOR')
+EXAMPLE_IMAGE_NAME = \
+ get_value('example.example_image_name', 'EXAMPLE_IMAGE_NAME')
+EXAMPLE_PRIVATE_NET_NAME = \
+ get_value('example.example_private_net_name', 'EXAMPLE_PRIVATE_NET_NAME')
+EXAMPLE_PRIVATE_SUBNET_NAME = \
+ get_value('example.example_private_subnet_name',
+ 'EXAMPLE_PRIVATE_SUBNET_NAME')
+EXAMPLE_PRIVATE_SUBNET_CIDR = \
+ get_value('example.example_private_subnet_cidr',
+ 'EXAMPLE_PRIVATE_SUBNET_CIDR')
+EXAMPLE_ROUTER_NAME = \
+ get_value('example.example_router_name', 'EXAMPLE_ROUTER_NAME')
+EXAMPLE_SECGROUP_NAME = \
+ get_value('example.example_sg_name', 'EXAMPLE_SECGROUP_NAME')
+EXAMPLE_SECGROUP_DESCR = \
+ get_value('example.example_sg_descr', 'EXAMPLE_SECGROUP_DESCR')
+VIMS_DATA_DIR = \
+ get_value('general.directories.dir_vIMS_data', 'VIMS_DATA_DIR')
+VIMS_TEST_DIR = \
+ get_value('general.directories.dir_repo_vims_test', 'VIMS_TEST_DIR')
+VIMS_TENANT_NAME = \
+ get_value('vIMS.general.tenant_name', 'VIMS_TENANT_NAME')
+VIMS_TENANT_DESCRIPTION = \
+ get_value('vIMS.general.tenant_description', 'VIMS_TENANT_DESCRIPTION')
+VIMS_IMAGES = get_value('vIMS.general.images', 'VIMS_IMAGES')
+CFY_MANAGER_BLUEPRINT = \
+ get_value('vIMS.cloudify.blueprint', 'CFY_MANAGER_BLUEPRINT')
+CFY_MANAGER_REQUIERMENTS = \
+ get_value('vIMS.cloudify.requierments', 'CFY_MANAGER_REQUIERMENTS')
+CFY_INPUTS = \
+ get_value('vIMS.cloudify.inputs', 'CFY_INPUTS')
+CW_BLUEPRINT = \
+ get_value('vIMS.clearwater.blueprint', 'CW_BLUEPRINT')
+CW_DEPLOYMENT_NAME = \
+ get_value('vIMS.clearwater.deployment-name', 'CW_DEPLOYMENT_NAME')
+CW_INPUTS = \
+ get_value('vIMS.clearwater.inputs', 'CW_INPUTS')
+CW_REQUIERMENTS = \
+ get_value('vIMS.clearwater.requierments', 'CW_REQUIERMENTS')
+PARSER_REPO = \
+ get_value('general.directories.dir_repo_parser', 'PARSER_REPO')
logger = ft_logger.Logger("functest_utils").getLogger()
-REPOS_DIR = os.getenv('repos_dir')
-FUNCTEST_REPO = ("%s/functest" % REPOS_DIR)
-
# ----------------------------------------------------------
#
def get_dict_by_test(testname):
- with open(get_testcases_file()) as f:
+ with open(get_testcases_file_dir()) as f:
testcases_yaml = yaml.safe_load(f)
for dic_tier in testcases_yaml.get("tiers"):
return status, details
-def get_testcases_file():
- return FUNCTEST_REPO + "/functest/ci/testcases.yaml"
+def get_testcases_file_dir():
+ return "/home/opnfv/repos/functest/functest/ci/testcases.yaml"
def get_functest_yaml():
functest_yaml = yaml.safe_load(f)
f.close()
return functest_yaml
+
+
+def print_separator():
+ logger.info("==============================================")
body = '~FUNTEST'
ind = 0
while key != 27:
- win.addstr(0, 44, ' Score: '+str(len(snake)-len(body))+' ')
+ win.addstr(0, 44, ' Score: ' + str(len(snake) - len(body)) + ' ')
win.timeout(140 - 2 * len(snake))
getkey = win.getch()
key = key if getkey == -1 else getkey
snake.insert(
- 0, [snake[0][0]+(key == KEY_RIGHT and 1 or
- key == KEY_LEFT and -1),
- snake[0][1]+(key == KEY_DOWN and 1 or
- key == KEY_UP and -1)])
- win.addch(snake[len(snake)-1][1], snake[len(snake)-1][0], ' ')
+ 0, [snake[0][0] + (key == KEY_RIGHT and 1 or
+ key == KEY_LEFT and -1),
+ snake[0][1] + (key == KEY_DOWN and 1 or
+ key == KEY_UP and -1)])
+ win.addch(snake[len(snake) - 1][1], snake[len(snake) - 1][0], ' ')
if win.inch(snake[0][1], snake[0][0]) & 255 == 32:
snake.pop()
elif win.inch(snake[0][1], snake[0][0]) & 255 == ord('@'):
print '\nSnake.PY-26lines by Kris Cieslak (defaultset.blogspot.com).'
print 'OPNFV adaptation by Functest dream team.'
- print 'Thanks for playing, your score: '+str(len(snake)-len(body)-1)+'.'
+ print 'Thanks for playing, your score: ' + \
+ str(len(snake) - len(body) - 1) + '.'
print 'Find and fix more bugs in your real OPNFV setup!\n'
import time
import functest.utils.functest_logger as ft_logger
-import functest.utils.functest_utils as ft_utils
import functest.utils.openstack_utils as os_utils
import yaml
-
+import functest.utils.functest_constants as ft_constants
logger = ft_logger.Logger("openstack_clean").getLogger()
-OS_SNAPSHOT_FILE = \
- ft_utils.get_functest_config("general.openstack.snapshot_file")
+OS_SNAPSHOT_FILE = ft_constants.OPENSTACK_SNAPSHOT_FILE
def separator():
#
import functest.utils.functest_logger as ft_logger
-import functest.utils.functest_utils as ft_utils
import functest.utils.openstack_utils as os_utils
import yaml
-
+import functest.utils.functest_constants as ft_constants
logger = ft_logger.Logger("openstack_snapshot").getLogger()
-OS_SNAPSHOT_FILE = \
- ft_utils.get_functest_config("general.openstack.snapshot_file")
+OS_SNAPSHOT_FILE = ft_constants.OPENSTACK_SNAPSHOT_FILE
def separator():
python $WORKSPACE/setup.py develop
+export CONFIG_FUNCTEST_YAML=$(pwd)/functest/ci/config_functest.yaml
# unit tests
# TODO: remove cover-erase
# To be deleted when all functest packages will be listed
Code Review / functest.git / commitdiff