if [[ -f ${OPENRC} ]]; then
echo "BOTTLENECKS INFO: openstack credentials path is ${OPENRC}"
- if [[ $INSTALLER_TYPE == 'compass' && ${BRANCH} == 'master' ]]; then
+ if [[ $INSTALLER_TYPE == 'compass' ]]; then
echo "BOTTLENECKS INFO: writing ${OS_CACERT} to ${OPENRC}"
echo "export OS_CACERT=${OS_CACERT}" >> ${OPENRC}
fi
- trigger:
name: 'compass-k8-nosdn-nofeature-ha-virtual-master-trigger'
triggers:
- - timed: '0 12 * * *'
+ - timed: '5 2 * * *'
- trigger:
name: 'compass-os-odl-sfc-ha-virtual-master-trigger'
triggers:
- trigger:
name: 'compass-k8-nosdn-nofeature-ha-virtual-euphrates-trigger'
triggers:
- - timed: '0 13 * * *'
+ - timed: '5 1 * * *'
# -------------------
# noha-virtual-euphrates
builders:
- shell: |
- echo "Nothing to verify!"
+ cd $WORKSPACE/ci
+ ./build.sh
FUNCTEST_IMAGE=opnfv/functest-${tier}:${DOCKER_TAG}
echo "Functest: Pulling Functest Docker image ${FUNCTEST_IMAGE} ..."
docker pull ${FUNCTEST_IMAGE}>/dev/null
- cmd="docker run --privileged=true ${envs} ${volumes} ${FUNCTEST_IMAGE} /bin/bash -c '${cmd_opt}'"
+ cmd="docker run --privileged=true ${envs} ${volumes} ${TESTCASE_OPTIONS} ${FUNCTEST_IMAGE} /bin/bash -c '${cmd_opt}'"
echo "Running Functest tier '${tier}'. CMD: ${cmd}"
eval ${cmd}
ret_value=$?
run_test() {
test_name=$1
- cmd_opt="prepare_env start && run_tests -r -t ${test_name}"
+ cmd_opt="prepare_env start && run_tests -t ${test_name}"
[[ $BUILD_TAG =~ "suite" ]] && cmd_opt="prepare_env start && run_tests -t ${test_name}"
ret_val_file="${HOME}/opnfv/functest/results/${BRANCH##*/}/return_value"
echo 0 > ${ret_val_file}
esac
echo "Functest: Pulling Functest Docker image ${FUNCTEST_IMAGE} ..."
docker pull ${FUNCTEST_IMAGE}>/dev/null
- cmd="docker run --privileged=true ${envs} ${volumes} ${FUNCTEST_IMAGE} /bin/bash -c '${cmd_opt}'"
+ cmd="docker run --privileged=true ${envs} ${volumes} ${TESTCASE_OPTIONS} ${FUNCTEST_IMAGE} /bin/bash -c '${cmd_opt}'"
echo "Running Functest test case '${test_name}'. CMD: ${cmd}"
eval ${cmd}
ret_value=$?
- master:
branch: '{stream}'
gs-pathname: ''
+ disabled: true
- euphrates:
branch: 'stable/{stream}'
gs-pathname: '/{stream}'
+ disabled: true
- job-template:
name: 'moon-verify-{stream}'
- shell: |
#!/bin/bash
echo "launch Moon unit tests"
- nosetest $WORKSPACE/keystone-moon/keystone/tests/moon/unit
+ #nosetest $WORKSPACE/keystone-moon/keystone/tests/moon/unit
stream:
- master:
branch: 'master'
- - danube:
+ - euphrates:
branch: 'stable/{stream}'
project: 'opnfvdocs'
project: '**'
branch: '{branch}'
files: 'docs/**/*.*'
- - timed: 'H H * * *'
builders:
- shell: |
if [[ "$BRANCH" == "master" ]]; then
DOCKER_TAG="latest"
elif [[ -n "${RELEASE_VERSION-}" ]]; then
- DOCKER_TAG=${BRANCH##*/}.${RELEASE_VERSION}
- # e.g. danube.1.0, danube.2.0, danube.3.0
+ DOCKER_TAG=${RELEASE_VERSION}
+ if git checkout ${RELEASE_VERSION}; then
+ echo "Successfully checked out the git tag ${RELEASE_VERSION}"
+ else
+ echo "The tag ${RELEASE_VERSION} doesn't exist in the repository. Existing tags are:"
+ git tag
+ exit 1
+ fi
else
DOCKER_TAG="stable"
fi
- string:
name: RELEASE_VERSION
default: ""
- description: "Release version, e.g. 1.0, 2.0, 3.0"
+ description: "Docker tag to be built, e.g. 5.0.0, opnfv-5.0.0, 5.0.RC1"
- string:
name: DOCKERFILE
default: "{dockerfile}"
# -------------------------------
distro:
- 'xenial':
- disabled: true
+ disabled: false
dib-os-release: 'xenial'
dib-os-element: 'ubuntu-minimal'
dib-os-packages: 'vlan,vim,less,bridge-utils,language-pack-en,iputils-ping,rsyslog,curl'
extra-dib-elements: 'openssh-server'
- 'centos7':
- disabled: true
+ disabled: false
dib-os-release: '7'
dib-os-element: 'centos-minimal'
dib-os-packages: 'vim,less,bridge-utils,iputils,rsyslog,curl'
extra-dib-elements: 'openssh-server'
- - 'suse':
- disabled: true
+ - 'opensuse423':
+ disabled: false
dib-os-release: '42.3'
dib-os-element: 'opensuse-minimal'
dib-os-packages: 'vim,less,bridge-utils,iputils,rsyslog,curl'
cat > bifrost_test.sh<<EOF
cd ~/bifrost
# provision 3 VMs; xcimaster, controller, and compute
-cd $WORKSPACE/bifrost
./scripts/bifrost-provision.sh
# list the provisioned VMs
-cd $WORKSPACE/bifrost
source env-vars
ironic node-list
sudo -H -E virsh list
EOF
chmod a+x bifrost_test.sh
-./xci/scripts/vm/start-new-vm.sh $DISTRO
+# Fix up distros
+case ${DISTRO} in
+ xenial) VM_DISTRO=ubuntu ;;
+ centos7) VM_DISTRO=centos ;;
+ *suse*) VM_DISTRO=opensuse ;;
+esac
-rsync -a $WORKSPACE/bifrost ${DISTRO,,}_xci_vm:~/bifrost
+./xci/scripts/vm/start-new-vm.sh $VM_DISTRO
-ssh ${DISTRO,,}_xci_vm "cd ~/bifrost && ./bifrost_test.sh"
+rsync -a $WORKSPACE/releng-xci ${VM_DISTRO}_xci_vm:~/bifrost
+
+ssh -F $HOME/.ssh/xci-vm-config ${VM_DISTRO}_xci_vm "cd ~/bifrost && ./bifrost_test.sh"
def ofctl_dump_flows(self, ssh_conn, br='br-int',
choose_table=None, timestamp=None):
try:
- cmd = 'ovs-ofctl -OOpenFlow13 dump-flows {0}'.format(br)
+ cmd = 'sudo ovs-ofctl -OOpenFlow13 dump-flows {0}'.format(br)
if choose_table is not None:
cmd = '{0} table={1}'.format(cmd, choose_table)
output = self.__remote_cmd(ssh_conn, cmd)
def vsctl_show(self, ssh_conn, timestamp=None):
try:
- cmd = 'ovs-vsctl show'
+ cmd = 'sudo ovs-vsctl show'
output = self.__remote_cmd(ssh_conn, cmd)
operation = 'vsctl_show'
host = self.__ssh_host(ssh_conn)
nb_test_runnable_for_this_scenario += 1
LOGGER.info(" Searching results for case %s ",
displayName)
- result = rp_utils.getResult(name, installer,
- s, version)
+ if "fuel" in installer:
+ result = rp_utils.getCaseScoreFromBuildTag(
+ name,
+ s_result)
+ else:
+ result = rp_utils.getCaseScore(name, installer,
+ s, version)
# if no result set the value to 0
if result < 0:
result = 0
project = test_case.getProject()
LOGGER.info(" Searching results for case %s ",
displayName)
- result = rp_utils.getResult(name, installer,
- s, version)
+ if "fuel" in installer:
+ result = rp_utils.getCaseScoreFromBuildTag(
+ name,
+ s_result)
+ else:
+ result = rp_utils.getCaseScore(name, installer,
+ s, version)
# at least 1 result for the test
if result > -1:
test_case.setCriteria(result)
# 2 iterations : max score = 20 (10x2)
# 3 iterations : max score = 20
# 4 or more iterations : max score = 30 (1x30)
+ LOGGER.info("Number of iterations for this scenario: %s",
+ len(s_result))
if len(s_result) > 3:
k_score = 3
elif len(s_result) < 2:
versions:
- master
- euphrates
- - danube
log:
log_file: reporting.log
blacklist:
- odl_netvirt
- juju_epc
+ - tempest_full_parallel
+ - rally_full
max_scenario_criteria: 50
test_conf: https://git.opnfv.org/cgit/functest/plain/functest/ci/testcases.yaml
log_level: ERROR
#
# http://www.apache.org/licenses/LICENSE-2.0
#
-from urllib2 import Request, urlopen, URLError
import logging
import json
import os
import pdfkit
import yaml
+from urllib2 import Request, urlopen, URLError
+
# ----------------------------------------------------------
#
"""
Get the list of Scenarios
"""
-
+ test_results = None
+ scenario_results = None
period = get_config('general.period')
url_base = get_config('testapi.url')
return nb_test_ok
-def getResult(testCase, installer, scenario, version):
+def getCaseScore(testCase, installer, scenario, version):
"""
Get Result for a given Functest Testcase
"""
return test_result_indicator
+def getCaseScoreFromBuildTag(testCase, s_results):
+ """
+ Get Results for a given Functest Testcase with arch filtering
+ """
+ url_base = get_config('testapi.url')
+ nb_tests = get_config('general.nb_iteration_tests_success_criteria')
+ test_result_indicator = 0
+ # architecture is not a result field...so we cannot use getResult as it is
+ res_matrix = []
+ try:
+ for s_result in s_results:
+ build_tag = s_result['build_tag']
+ d = s_result['start_date']
+ res_matrix.append({'date': d,
+ 'build_tag': build_tag})
+ # sort res_matrix
+ filter_res_matrix = sorted(res_matrix, key=lambda k: k['date'],
+ reverse=True)[:nb_tests]
+ for my_res in filter_res_matrix:
+ url = ("http://" + url_base + "?case=" + testCase +
+ "&build_tag=" + my_res['build_tag'])
+ request = Request(url)
+ response = urlopen(request)
+ k = response.read()
+ results = json.loads(k)
+ if "PASS" in results['results'][0]['criteria']:
+ test_result_indicator += 1
+ except:
+ print "No results found for this case"
+ if test_result_indicator > 2:
+ test_result_indicator = test_result_indicator - 1
+
+ return test_result_indicator
+
+
def getJenkinsUrl(build_tag):
"""
Get Jenkins url_base corespoding to the last test CI run
# With debug_on set to true, error traces will be shown in HTTP responses
debug = True
-authenticate = False
+token_check = False
+authenticate = True
[ui]
url = http://localhost:8000
return swagger.Application(
url_mappings.mappings,
debug=CONF.api_debug,
- auth=CONF.api_authenticate,
+ auth=CONF.api_token_check,
cookie_secret='opnfv-testapi',
)
from opnfv_testapi.common import constants
from opnfv_testapi.common import message
from opnfv_testapi.common import raises
+from opnfv_testapi.common.config import CONF
from opnfv_testapi.db import api as dbapi
def is_authorized(method):
@functools.wraps(method)
def wrapper(self, *args, **kwargs):
- if self.table in ['pods']:
+ if CONF.api_authenticate and self.table in ['pods']:
testapi_id = self.get_secure_cookie(constants.TESTAPI_ID)
if not testapi_id:
raises.Unauthorized(message.not_login())
return wrap
+def values_check(xstep):
+ @functools.wraps(xstep)
+ def wrap(self, *args, **kwargs):
+ checks = kwargs.pop('values_check', {})
+ if checks:
+ for field, check, options in checks:
+ if not check(field, options):
+ raises.BadRequest(message.invalid_value(field, options))
+ ret = yield gen.coroutine(xstep)(self, *args, **kwargs)
+ raise gen.Return(ret)
+ return wrap
+
+
def new_not_exists(xstep):
@functools.wraps(xstep)
def wrap(self, *args, **kwargs):
return '{} Missing'.format(name)
+def invalid_value(name, options):
+ return '{} must be in {}'.format(name, options)
+
+
def exist(key, value):
return '{} [{}] {}'.format(key, value, exist_base)
@check.valid_token
@check.no_body
@check.miss_fields
+ @check.values_check
@check.carriers_exist
@check.new_not_exists
def _create(self, **kwargs):
return {'project_name': self.json_args.get('project_name'),
'name': self.json_args.get('case_name')}
+ def options_check(field, options):
+ return self.json_args.get(field).upper() in options
+
miss_fields = ['pod_name', 'project_name', 'case_name']
carriers = [('pods', pod_query),
('projects', project_query),
('testcases', testcase_query)]
+ values_check = [('criteria', options_check, ['PASS', 'FAIL'])]
- self._create(miss_fields=miss_fields, carriers=carriers)
+ self._create(miss_fields=miss_fields,
+ carriers=carriers,
+ values_check=values_check)
class ResultsUploadHandler(ResultsCLHandler):
assert CONF.mongo_dbname == 'test_results_collection'
assert CONF.api_port == 8000
assert CONF.api_debug is True
- assert CONF.api_authenticate is False
+ assert CONF.api_token_check is False
+ assert CONF.api_authenticate is True
assert CONF.ui_url == 'http://localhost:8000'
self.version = 'C'
self.build_tag = 'v3.0'
self.scenario = 'odl-l2'
- self.criteria = 'passed'
+ self.criteria = 'PASS'
self.trust_indicator = result_models.TI(0.7)
self.start_date = str(datetime.now())
self.stop_date = str(datetime.now() + timedelta(minutes=1))
req.case_name = None
return req
+ @executor.create(httplib.BAD_REQUEST,
+ message.invalid_value('criteria', ['PASS', 'FAIL']))
+ def test_invalid_criteria(self):
+ req = self.req_d
+ req.criteria = 'invalid'
+ return req
+
@executor.create(httplib.FORBIDDEN, message.not_found_base)
def test_noPod(self):
req = self.req_d
from opnfv_testapi.common import constants
from opnfv_testapi.common import raises
+from opnfv_testapi.common.config import CONF
from opnfv_testapi.resources import handlers
from opnfv_testapi.resources import models
self.table_cls = User
def get(self):
- username = self.get_secure_cookie(constants.TESTAPI_ID)
- if username:
- self._get_one(query={'user': username})
+ if CONF.api_authenticate:
+ username = self.get_secure_cookie(constants.TESTAPI_ID)
+ if username:
+ self._get_one(query={'user': username})
+ else:
+ raises.Unauthorized('Unauthorized')
else:
- raises.Unauthorized('Unauthorized')
+ self.finish_request(User('anonymous',
+ 'anonymous@linuxfoundation.com',
+ 'anonymous lf',
+ constants.TESTAPI_USERS).format())
Code Review / releng.git / commitdiff