From ef624608bc205ddb8d9a4a744fbc8873dc769c2e Mon Sep 17 00:00:00 2001 From: "lemon.higgins" Date: Thu, 11 Jun 2020 12:06:50 +0000 Subject: [PATCH] add codes of test frame --- mugen/README.md | 102 ++++++++ mugen/conf/env.conf | 15 ++ mugen/libs/locallibs/common_lib.sh | 195 +++++++++++++++ mugen/libs/locallibs/sshcmd.sh | 136 +++++++++++ mugen/libs/locallibs/sshscp.sh | 108 +++++++++ mugen/runoet.sh | 222 ++++++++++++++++++ mugen/suite2cases/testsuite | 2 + .../oe_test_casename_01.sh | 67 ++++++ .../oe_test_casename_02.py | 34 +++ 9 files changed, 881 insertions(+) create mode 100644 mugen/README.md create mode 100644 mugen/conf/env.conf create mode 100644 mugen/libs/locallibs/common_lib.sh create mode 100644 mugen/libs/locallibs/sshcmd.sh create mode 100644 mugen/libs/locallibs/sshscp.sh create mode 100644 mugen/runoet.sh create mode 100644 mugen/suite2cases/testsuite create mode 100644 mugen/testcases/testsuite/oe_test_casename_01/oe_test_casename_01.sh create mode 100644 mugen/testcases/testsuite/oe_test_casename_02/oe_test_casename_02.py diff --git a/mugen/README.md b/mugen/README.md new file mode 100644 index 0000000..e6c5588 --- /dev/null +++ b/mugen/README.md @@ -0,0 +1,102 @@ +# mugen + +mugen是openEuler社区开发的测试框架，提供公共配置和方法以便社区开发者进行测试代码的编写和执行 + +## mugen使用说明 + +用户对mugen框架的使用是通过执行runoet接口来实现。runoet的接口详细说明如下： + +- 参数说明： +\-c: 测试环境配置 +\-a：执行所有的测试用例 +\-f：指定测试套执行 +\-r：指定测试套下测试用例的执行，当前支持单用例 +\-x：进入调试模式下执行测试用例 + +- 使用示例 + - 配置测试环境 + `bash runoet -c` + - 执行所有用例 + `bash runoet -a` + - 执行指定测试套下所有用例 + `bash runoet -f "xxx"` + - 执行指定的用例 + `bash runoet -f "xxx" -r "yyy"` + - 进入调试模式下执行用例 + `bash runoet -f "xxx" -r "yyy" -x` + +- 使用说明 + - 测试环境需要通过runoet -c进行环境的配置，具体配置项用户可在conf/env.conf中进行配置 + - 所有的测试用例存放在testcases目录下 + - 测试套和测试用例的对应关系需要在suite2cases目录中进行定义 + - 大家可以参考现有的测试模板进行用例开发 + +- 框架目录 +  ![runoet_tree](data:image/png;base64,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) + +## mugen框架中shell公共方法 + +- SSH_CMD + - 对ssh进行封装，远程执行命令时无需进入交互模式 + - 使用方法 + `SSH_CMD "$cmd" $REMOTEIP $REMOTEUSER $REMOTEPASSWD` + +- SSH_SCP + - 对scp进行封装，执行scp命令时无需进入交互模式 + - 使用方法 + - 本地文件传输到对端 + `SSH_SCP $file $user@$ip:$remote_path "$remotepasswd"` + - 本地文件传输到对端 + `SSH_SCP $user@$ip:$remote_path/$file $local_path "$remotepasswd"` + +- LOG_INFO + - 输出INFO级日子 + `LOG_INFO $log` + +- LOG_WARN + - 输出WARN级日子 + `LOG_WARN $log` + +- LOG_ERROR + - 输出ERROR级日子 + `LOG_WARN $log` + +- DNF_INSTALL + - 用于安装软件包 + `DNF_INSTALL "vim bc nettools"` + - 特别说明：建议需要安装的软件包，在前置处理中一次性安装完成 + +- DNF_REMOVE + - 用于卸载软件包 + - 特别说明：依赖于 DNF_INSTALL，为了保证环境恢复的，会将DNF_INSTALL安装的所有包都进行卸载 + `DNF_REMOVE` + - 如果不想依赖DNF_INSTALL，单纯想要卸载某个包，需要在方法最后添加参数“1” + `DNF_REMOVE "tree" 1` + +- REMOTE_REBOOT_WAIT + - 多节点环境中，当对端进行重启操作，将用于等待对端完全重启 + `REMOTE_REBOOT_WAIT $REMOTEUSER $REMOTEPASSWD $REMOTEIP` + +- SLEEP_WAIT + - 需要睡眠等待大于1秒的操作，不要直接使用sleep，建议使用SLEEP_WAIT + `SLEEP_WAIT 3` + +- CHECK_RESULT + - 对测试点进行检查，mugen框架将会对执行结果进行统计，所以务必使用此方法进行判断 + - 参数说明： + - 参数1：实际结果 + - 参数2：预期结果，默认为“0” + - 参数3：判断模式，默认为“0”：需要实际结果和预期结果一致；选择“1”：需要实际结果和预期结果不一致 + `CHECK_RESULT 0 0` + +## mugen中python公共方法 + +- 尽情期待。。。 + +## mugen的日志说明 + +所有用例执行结束之后 + +- 日志将存储到和runoet.sh同层的logs目录下面 +- 执行结果将会存放到和runoet.sh同层的results目录下面 +- logs和results目录会在用例执行之后自动化生成 diff --git a/mugen/conf/env.conf b/mugen/conf/env.conf new file mode 100644 index 0000000..4fc5444 --- /dev/null +++ b/mugen/conf/env.conf @@ -0,0 +1,15 @@ +export OET_PATH=/opt/litf + +export FRAME=$(uname -i) + +export LOCAL_IP=$(ip addr show | grep inet | grep -v inet6 | grep -Ewv "lo.*|docker.*|bond.*|vlan.*|virbr.*|br-.*" | awk '{print $2}' | awk -F "/" '{print $1}' | head -1) + +export LOCAL_USER=$(echo ${USER}) + +export LOCAL_PASSWD="" + +export REMOTE_IP="" + +export REMOTE_USER="" + +export REMOTE_PASSWD="" diff --git a/mugen/libs/locallibs/common_lib.sh b/mugen/libs/locallibs/common_lib.sh new file mode 100644 index 0000000..60951af --- /dev/null +++ b/mugen/libs/locallibs/common_lib.sh @@ -0,0 +1,195 @@ +#!/usr/bin/bash +# Copyright (c) [2020] Huawei Technologies Co.,Ltd.ALL rights reserved. +# This program is licensed under Mulan PSL v2. +# You can use it according to the terms and conditions of the Mulan PSL v2. +# http://license.coscl.org.cn/MulanPSL2 +# THIS PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +# See the Mulan PSL v2 for more details. +#################################### +#@Author : lemon.higgins +#@Contact : lemon.higgins@aliyun.com +#@Date : 2020-04-09 09:39:43 +#@License : Mulan PSL v2 +#@Version : 1.0 +#@Desc : Public function +##################################### + +function LOG_INFO() { + printf "$(date +%Y-%m-%d\ %T) $0 [ INFO ] %s\n" "$@" +} + +function LOG_WARN() { + printf "$(date +%Y-%m-%d\ %T) $0 [ WARN ] %s\n" "$@" +} + +function LOG_ERROR() { + printf "$(date +%Y-%m-%d\ %T) $0 [ ERROR ] %s\n" "$@" +} + +function DNF_INSTALL() { + __pkg_list=$1 + if [ -z "${__pkg_list}" ]; then + LOG_ERROR "Wrong parameter." + exit 1 + fi + reponames=$(grep '^\[.*\]' /etc/yum.repos.d/*.repo | tr -d [] | sed -e ':a;N;$!ba;s/\n/ /g') + mapfile -t __install_pkgs < <(dnf -y install ${__pkg_list[*]} | grep -wE "${reponames// /|}" | grep -wE "$(uname -m)|noarch" | awk '{print $1}') + + if ! dnf -y install ${__pkg_list[*]}; then + LOG_ERROR "pkg_list:${__pkg_list[*]} install failed." + exit 1 + fi + + __installed_pkgs+=" ${__install_pkgs[*]}" + + return 0 +} + +function DNF_REMOVE() { + __pkg_list=$1 + type=${2-0} + + if [ ${type} -eq 0 ]; then + if ! dnf -y remove ${__installed_pkgs[*]} ${__pkg_list[*]}; then + LOG_ERROR "pkg_list:${__installed_pkgs[*]} ${__pkg_list[*]} remove failed." + exit 1 + fi + else + if ! dnf -y remove ${__pkg_list}; then + LOG_ERROR "pkg_list:${__pkg_list[*]} remove failed." + exit 1 + fi + fi +} + +function SLEEP_WAIT() { + wait_time=${1-1} + cmd=$2 + sleep_time=0 + + while [ $sleep_time -lt $wait_time ]; do + sleep 1 + if [ -n "$cmd" ]; then + if $cmd; then + return 0 + fi + fi + ((sleep_time++)) + done +} + +function REMOTE_REBOOT_WAIT() { + remoteuser=$1 + remotepasswd=$2 + remoteip=$3 + count=0 + + if [[ "$(dmidecode -s system-product-name)" =~ "KVM" ]]; then + SLEEP_WAIT 60 + else + SLEEP_WAIT 200 + fi + + while [ $count -lt 60 ]; do + if ping -c 1 $remoteip; then + if SSH_CMD "echo '' > /dev/null 2>&1" $remoteip $remoteuser $remotepasswd; then + return 0 + else + SLEEP_WAIT 10 + ((count++)) + fi + else + SLEEP_WAIT 10 + ((count++)) + fi + done + + return 1 +} + +function CHECK_RESULT() { + actual_result=$1 + expect_result=${2-0} + mode=${3-0} + error_log=$4 + + if [ -z "$actual_result" ]; then + LOG_ERROR "Missing actual error code." + return 1 + fi + + if [ $mode -eq 0 ]; then + test "$actual_result"x != "$expect_result"x && { + LOG_ERROR "$error_log" + ((exec_result++)) + all_result="$all_result $exec_result" + } + else + test "$actual_result"x == "$expect_result"x && { + LOG_ERROR "$error_log" + ((exec_result++)) + all_result="$all_result $exec_result" + } + fi +} + +function CASE_RESULT() { + [[ -z $exec_result ]] && { + LOG_INFO "The case execute succeed." + exec_result=0 + all_result=0 + return 0 + } + + for ret in "${all_result[@]}"; do + LOG_ERROR "Test point $ret: execute failed." + done + exec_result=0 + all_result=0 + return 1 +} + +function SSH_CMD() { + cmd=$1 + remoteip=$2 + remotepasswd=${3-openEuler12#$} + remoteuser=${4-root} + timeout=${5-300} + connport=${6-22} + + bash ${OET_PATH}/libs/locallibs/sshcmd.sh -c "$cmd" -i "$remoteip" -u "$remoteuser" -p "$remotepasswd" -t "$timeout" -o "$connport" + ret=$? + test $ret -ne 0 && LOG_ERROR "Failed in remote CMD operation:$ret" + return $ret +} + +function SSH_SCP() { + src=$1 + dest=$2 + remotepasswd=${3-openEuler12#$} + connport=${4-22} + + bash ${OET_PATH}/libs/locallibs/sshscp.sh -p "$remotepasswd" -o "$connport" -s "$src" -d "$dest" + ret=$? + test $ret -ne 0 && LOG_ERROR "Failed in remote SCP operation: $ret" + return $ret +} + +function main() { + trap post_test EXIT INT TERM + + if ! rpm -qa | grep expect >/dev/null 2>&1; then + dnf install expect -y + fi + + config_params + + pre_test + + run_test + + CASE_RESULT + test $? -eq 0 || exit 1 +} diff --git a/mugen/libs/locallibs/sshcmd.sh b/mugen/libs/locallibs/sshcmd.sh new file mode 100644 index 0000000..6d046db --- /dev/null +++ b/mugen/libs/locallibs/sshcmd.sh @@ -0,0 +1,136 @@ +#!/usr/bin/bash +# Copyright (c) [2020] Huawei Technologies Co.,Ltd.ALL rights reserved. +# This program is licensed under Mulan PSL v2. +# You can use it according to the terms and conditions of the Mulan PSL v2. +# http://license.coscl.org.cn/MulanPSL2 +# THIS PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +# See the Mulan PSL v2 for more details. +#################################### +#@Author : lemon.higgins +#@Contact : lemon.higgins@aliyun.com +#@Date : 2020-04-08 16:13:40 +#@License : Mulan PSL v2 +#@Version : 1.0 +#@Desc : Encapsulate ssh, user t directly, and execute remote commands +#################################### + +source ${OET_PATH}/libs/locallibs/common_lib.sh +function sshcmd() { + cmd=$1 + remoteip=$2 + remotepasswd=${3} + remoteuser=${4} + timeout=${5} + connport=${6} + + test "$cmd"x = ""x && LOG_ERROR "Lack of execute command." && exit 1 + cmd=${cmd//\$/\\\$} + + test "$remoteip"x = ""x && LOG_ERROR "Missing ip." + test "$(echo ${remoteip} | awk -F"." '{if ($1!=0 && $NF!=0) split ($0,IPNUM,".")} END { for (k in IPNUM) if (IPNUM[k]==0) print IPNUM[k]; else if (IPNUM[k]!=0 && IPNUM[k]!~/[a-z|A-Z]/ && length(IPNUM[k])<=3 && IPNUM[k]<255 && IPNUM[k]!~/^0/) print IPNUM[k]}' | wc -l)" -ne 4 && LOG_ERROR "the remote ip is Incorrect." && exit 1 + if ping -c 1 ${remoteip} | grep "100% packet loss"; then + LOG_ERROR "connection to $remoteip failed." + exit 101 + fi + + test "$remoteuser"x = "root"x && LOG_WARN "the remote user uses the default configuration." + + test "$remotepasswd"x = "openEuler12#$"x && LOG_WARN "the remote password uses the default configuration." + + test "$timeout"x = "15"x && LOG_WARN "the timeout uses the default configuration." + + test "$connport"x = "22"x && LOG_WARN "the connect port using the default configuration" + + cmd_last_world=$(echo ${cmd} | awk '{print $NF}') + + e_time=${timeout} + + test "$cmd_last_world"x == "&"x && { + timeout=0 + e_time=-1 + } + + expect <<-EOF + + set timeout ${e_time} + + spawn ssh -o "ConnectTimeout=${timeout}" -p ${connport} ${remoteuser}@${remoteip} "$cmd" + + expect { + "Are you sure you want to continue connecting*" + { + send "yes\r" + expect "*\[P|p]assword:" + send "${remotepasswd}\r" + } + "*\[P|p]assword:" + { + send "${remotepasswd}\r" + } + timeout + { + end_user "connection to $remoteip timed out: \$expect_out(buffer)\n" + exit 101 + } + eof + { + catch wait result + exit [lindex \$result 3] + } + } + expect { + eof { + catch wait result + exit [lindex \$result 3] + } + "\[P|p]assword:" + { + send_user "invalid password or account again.\$expect_out(buffer)\n" + send "${remotepasswd}\r" + } + timeout + { + send_user "connection to $remoteip timed out: \$expect_out(buffer)\n" + exit 101 + } + } + } +EOF + exit $? +} + +usage() { + printf "Usage: sshcmd.sh -c \"command\" -i \"remote machinet ip\" [-u login_user] [-p login_password] [-o port] [-t timeout]" +} + +while getopts "c:i:p:u:t:o:h" OPTIONS; do + case $OPTIONS in + c) cmd="$OPTARG" ;; + i) remoteip="$OPTARG" ;; + u) remoteuser="$OPTARG" ;; + p) remotepasswd="$OPTARG" ;; + t) timeout="$OPTARG" ;; + o) connport="$OPTARG" ;; + \?) + printf "ERROR - Invalid parameter" >&2 + usage + exit 1 + ;; + *) + printf "ERROR - Invalid parameter" >&2 + usage + exit 1 + ;; + esac +done + +if [ "$cmd"x = ""x ] || [ "$remoteip"x = ""x ]; then + usage + exit 1 +fi + +sshcmd "$cmd" "$remoteip" "${remotepasswd-openEuler12#$}" "${remoteuser-root}" "${timeout-300}" "${connport-22}" + +exit $? diff --git a/mugen/libs/locallibs/sshscp.sh b/mugen/libs/locallibs/sshscp.sh new file mode 100644 index 0000000..aadd160 --- /dev/null +++ b/mugen/libs/locallibs/sshscp.sh @@ -0,0 +1,108 @@ +#!/usr/bin/bash +# Copyright (c) [2020] Huawei Technologies Co.,Ltd.ALL rights reserved. +# This program is licensed under Mulan PSL v2. +# You can use it according to the terms and conditions of the Mulan PSL v2. +# http://license.coscl.org.cn/MulanPSL2 +# THIS PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +# See the Mulan PSL v2 for more details. +#################################### +#@Author : lemon.higgins +#@Contact : lemon.higgins@aliyun.com +#@Date : 2020-04-09 17:58:35 +#@License : Mulan PSL v2 +#@Version : 1.0 +#@Desc : 封装scp命令，供文件传输使用 +#################################### + +source ${OET_PATH}/libs/locallibs/common_lib.sh +function sshscp() { + src=$1 + dest=$2 + remotepasswd=${3-openEuler12#$} + connport=${4-22} + + test "$src"x = ""x && LOG_ERROR "No transfer file provided." && exit 1 + + test "$dest"x = ""x && LOG_ERROR "No file storage path provided." && exit 1 + + test "$remotepasswd"x = "openEuler12#$"x && LOG_WARN "the remote password uses the default configuration." + + test "$connport"x = "22"x && LOG_WARN "the connect port using the default configuration" + + expect <<-EOF + set timeout -1 + spawn scp -P $connport -r $src $dest + expect { + "Are you sure you want to continue connecting*" + { + send "yes\r" + expect "\[P|p]assword:" + send "${remotepasswd}\r" + } + -re "\[P|p]assword:" + { + send "${remotepasswd}\r" + } + timeout + { + send_user "connection to remote timed out: \$expect_out(buffer)\n" + exit 101 + } + eof + { + catch wait result + exit [lindex \$result 3] + } + } + expect { + eof + { + catch wait result + exit [lindex \$result 3] + } + -re "\[P|p]assword:" + { + send_user "invalid password or account. \$expect_out(buffer)\n" + exit 13 + } + timeout + { + send_user "connection to remote timed out : \$expect_out(buffer)\n" + exit 101 + } + } +EOF + exit $? +} + +usage() { + printf "Usage: sshscp.sh -s src(user@ip:path) -d destination((user@ip:path)) [-p login_password] [-o port] -r -t timeout" +} + +while getopts "p:s:d:o:h" OPTIONS; do + case $OPTIONS in + p) remotepasswd="$OPTARG" ;; + s) src="$OPTARG" ;; + d) dest="$OPTARG" ;; + o) connport="$OPTARG" ;; + h) + usage + exit 1 + ;; + \?) + printf "ERROR - Invalid parameter" >&2 + usage + exit 1 + ;; + *) + printf "ERROR - Invalid parameter" >&2 + usage + exit 1 + ;; + esac +done + +sshscp "$src" "$dest" "$remotepasswd" "$connport" +exit $? diff --git a/mugen/runoet.sh b/mugen/runoet.sh new file mode 100644 index 0000000..dacc03c --- /dev/null +++ b/mugen/runoet.sh @@ -0,0 +1,222 @@ +#!/usr/bin/bash +# Copyright (c) [2020] Huawei Technologies Co.,Ltd.ALL rights reserved. +# This program is licensed under Mulan PSL v2. +# You can use it according to the terms and conditions of the Mulan PSL v2. +# http://license.coscl.org.cn/MulanPSL2 +# THIS PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +# See the Mulan PSL v2 for more details. +# #################################### +# @Author : lemon.higgins +# @Contact : lemon.higgins@aliyun.com +# @Date : 2020-04-14 16:45:43 +# @License : Mulan PSL v2 +# @Version : 1.0 +# @Desc : Used to execute test cases +# #################################### +oet_path=$( + cd "$(dirname "$0")" || exit 1 + pwd +) +source ${oet_path}/libs/locallibs/common_lib.sh + +function usage() { + printf "Usage: \n + -c: configuration environment of test framework\n + -a: execute all use cases\n + -f：designated test suite\n + -r：designated test case\n + -x：the shell script is executed in debug mode\n + \n + Example: bash runoet.sh -f test_suite -r test_case -x\n" +} + +function deploy_env() { + sed -i "s#OET_PATH.*#OET_PATH=${oet_path}#g" ${oet_path}/conf/env.conf + + if ! grep "${oet_path}/conf/env.conf" ~/.bash_profile >/dev/null 2>&1; then + echo "source ${oet_path}/conf/env.conf" >>~/.bash_profile + fi + + source ~/.bash_profile +} + +function end_test_case() { + case_code=$1 + exec 1>&6 6>&- + exec 2>&7 7>&- + LOG_INFO "The case exit by code ${case_code}" + LOG_INFO "End to run testcase:${test_case}" + + test ${case_code} -ne 0 && ((fail_num++)) +} + +function run_all_cases() { + cd ${OET_PATH}/suite2cases || exit 1 + mapfile test_suites < <(ls | sort -u) + test ${#test_suites[*]} -eq 0 && { + LOG_ERROR "Can't find recording about test_suites." + end_test_case 1 + return 1 + } + + cd ${OET_PATH} || exit 1 + for test_suite in ${test_suites[*]}; do + run_test_suite $test_suite + done +} + +function run_test_suite() { + test_suite=$1 + + if ! find ${OET_PATH}/suite2cases -type f -name ${test_suite} >/dev/null 2>&1; then + LOG_ERROR "In the suite2cases directory, Can't find the file of testsuite:${test_suite}." + end_test_case 1 + return 1 + fi + + while read -r test_case; do + run_test_case $test_suite $test_case + done <"${OET_PATH}/suite2cases/${test_suite}" + cd ${OET_PATH} || exit 1 +} + +function run_test_case() { + test_suite=$1 + test_case=$2 + + LOG_INFO "start to run testcase:${test_case}" + + log_path=${OET_PATH}/logs/${test_suite}/${test_case} + mkdir -p ${log_path} + + exec 6>&1 + exec 7>&2 + exec >${log_path}/"$(date +%Y-%m-%d-%T)".log 2>&1 + + ((case_num++)) + + if ! find ${OET_PATH}/suite2cases -type f -name ${test_suite} >/dev/null 2>&1; then + LOG_ERROR "In the suite2cases directory, Can't find the file of testsuite:${test_suite}." + end_test_case 1 + return 1 + elif ! find ${OET_PATH}/testcases -type d -name ${test_suite} >/dev/null 2>&1; then + LOG_ERROR "Can't find the dir of testsuite:${test_suite}." + end_test_case 1 + return 1 + fi + + if ! grep -w ${test_case} ${OET_PATH}/suite2cases/${test_suite} >/dev/null 2>&1; then + LOG_ERROR "In the suite2cases directory, no testcase:${test_case} is found inside the ${test_suite} file." + end_test_case 1 + return 1 + elif ! find ${OET_PATH}/testcases -type d -name ${test_suite} >/dev/null 2>&1; then + LOG_ERROR "Can't find the dir of testcase:${test_case}." + end_test_case 1 + return 1 + elif ! find ${OET_PATH}/testcases/${test_suite} -type f -name "${test_case}*" >/dev/null 2>&1; then + LOG_ERROR "Can't find the script of testcase:${test_case}." + end_test_case 1 + return 1 + fi + + case_path=$(find ${OET_PATH}/testcases/${test_suite} -type f -name "${test_case}*" | sed -e "s/${test_case}\..*//g") + cd ${case_path} || exit 1 + + script_type=$(ls ${test_case}* | awk -F '.' '{print $NF}') + + if [[ "$script_type"x == "sh"x ]] || [[ "$script_type"x == "bash"x ]]; then + if [ "$command_x"x == "yes"x ]; then + bash -x ${test_case}.sh + case_result=$? + else + bash ${test_case}.sh + case_result=$? + fi + elif [ "$script_type"x == "py"x ]; then + python3 ${test_case}.py + case_result=$? + fi + + if [ $case_result -eq 0 ]; then + touch ${OET_PATH}/results/succeed/${test_case} + else + touch ${OET_PATH}/results/failed/${test_case} + fi + + test $case_result == 0 && { + end_test_case 0 + ((succee_num++)) + } + test $case_result != 0 && { + end_test_case ${case_result} + } +} + +function run_test() { + test_suite=$1 + test_case=$2 + case_num=0 + fail_num=0 + succee_num=0 + + if echo "$@" | grep -e '-a\|-f\|-r' >/dev/null 2>&1; then + rm -rf ${OET_PATH}/results + mkdir -p ${OET_PATH}/results/succeed + mkdir -p ${OET_PATH}/results/failed + fi + + echo "$@" | grep -e '-f' >/dev/null 2>&1 && ! echo "$@" | grep -e '-r' >/dev/null 2>&1 && { + run_test_suite $test_suite + } + + echo "$@" | grep -e '-f' | grep -e '-r' >/dev/null 2>&1 && { + run_test_case $test_suite $test_case + } + + if echo "$@" | grep -e '-a\|-f\|-r' >/dev/null 2>&1; then + LOG_INFO "A total of ${case_num} use cases were executed, with ${succee_num} successes and ${fail_num} failures." + fi + + if [ ${succee_num} != ${case_num} ]; then + return 1 + fi +} + +export command_x="no" +while getopts ":xachr:f:" arg; do + case $arg in + x) + command_x="yes" + ;; + a) + run_all_cases + ;; + c) + deploy_env + ;; + f) + test_suite=$OPTARG + [[ -z "$test_suite" ]] && { + usage + exit 1 + } + ;; + r) + test_case=$OPTARG + [[ -z "$test_case" ]] && { + usage + exit 1 + } + ;; + h) + usage + ;; + *) + usage + ;; + esac +done + +run_test $test_suite $test_case "$@" diff --git a/mugen/suite2cases/testsuite b/mugen/suite2cases/testsuite new file mode 100644 index 0000000..1c15645 --- /dev/null +++ b/mugen/suite2cases/testsuite @@ -0,0 +1,2 @@ +oe_test_casename_01 +oe_test_casename_02 diff --git a/mugen/testcases/testsuite/oe_test_casename_01/oe_test_casename_01.sh b/mugen/testcases/testsuite/oe_test_casename_01/oe_test_casename_01.sh new file mode 100644 index 0000000..5b1de5a --- /dev/null +++ b/mugen/testcases/testsuite/oe_test_casename_01/oe_test_casename_01.sh @@ -0,0 +1,67 @@ +#!/usr/bin/bash + +# Copyright (c) [2020] Huawei Technologies Co.,Ltd.ALL rights reserved. +# This program is licensed under Mulan PSL v2. +# You can use it according to the terms and conditions of the Mulan PSL v2. +# http://license.coscl.org.cn/MulanPSL2 +# THIS PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +# See the Mulan PSL v2 for more details. +#################################### +#@Author : lemon.higgins +#@Contact : lemon.higgins@aliyun.com +#@Date : 2020-04-09 09:39:43 +#@License : Mulan PSL v2 +#@Version : 1.0 +#@Desc : Take the test ls command as an example +##################################### + +source ${OET_PATH}/libs/locallibs/common_lib.sh + +# 需要预加载的数据、参数配置 +function config_params() +{ + LOG_INFO "Start to config params of the case." + + LOG_INFO "No params need to config." + + LOG_INFO "End to config params of the case." +} + +# 测试对象、测试需要的工具等安装准备 +function pre_test() +{ + LOG_INFO "Start to prepare the test environment." + + LOG_INFO "No pkgs need to install." + + LOG_INFO "End to prepare the test environment." +} + +# 测试点的执行 +function run_test() +{ + LOG_INFO "Start to run test." + + # 测试命令：ls + ls -CZl -all + CHECK_RESULT 0 + + # 测试/目录下是否存在proc|usr|roor|var|sys|etc|boot|dev目录 + CHECK_RESULT "$(ls / | grep -cE 'proc|usr|roor|var|sys|etc|boot|dev')" 7 + + LOG_INFO "End to run test." +} + +# 后置处理，恢复测试环境 +function post_test() +{ + LOG_INFO "Start to restore the test environment." + + LOG_INFO "Need't to restore the tet environment." + + LOG_INFO "End to restore the test environment." +} + +main $@ diff --git a/mugen/testcases/testsuite/oe_test_casename_02/oe_test_casename_02.py b/mugen/testcases/testsuite/oe_test_casename_02/oe_test_casename_02.py new file mode 100644 index 0000000..871db55 --- /dev/null +++ b/mugen/testcases/testsuite/oe_test_casename_02/oe_test_casename_02.py @@ -0,0 +1,34 @@ +#!/usr/bin/bash + +# Copyright (c) [2020] Huawei Technologies Co.,Ltd.ALL rights reserved. +# This program is licensed under Mulan PSL v2. +# You can use it according to the terms and conditions of the Mulan PSL v2. +# http://license.coscl.org.cn/MulanPSL2 +# THIS PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +# See the Mulan PSL v2 for more details. +#################################### +# @Author : lemon.higgins +# @Contact : lemon.higgins@aliyun.com +# @Date : 2020-04-09 09:39:43 +# @License : Mulan PSL v2 +# @Version : 1.0 +# @Desc : Take the test ls command as an example +##################################### + + +import subprocess + +ret = 0 + +cmd_status = subprocess.getstatusoutput("ls -CZl --all")[0] +if cmd_status != 0: + ret += 1 + +dir_num = subprocess.getoutput( + "ls / | grep -cE 'proc|usr|roor|var|sys|etc|boot|dev'") +if dir_num != "7": + ret += 1 + +exit(ret) -- GitLab