summaryrefslogtreecommitdiff
path: root/run_tests.sh
blob: 8164b6664b693b0a370bbfd67a3ae406427943d9 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
#!/bin/bash

set -eu

function usage {
    echo "Usage: $0 [OPTION]..."
    echo "Run Manila's test suite(s)"
    echo ""
    echo "  -V, --virtual-env           Always use virtualenv.  Install automatically if not present"
    echo "  -N, --no-virtual-env        Don't use virtualenv.  Run tests in local environment"
    echo "  -s, --no-site-packages      Isolate the virtualenv from the global Python environment"
    echo "  -r, --recreate-db           Recreate the test database (deprecated, as this is now the default)."
    echo "  -n, --no-recreate-db        Don't recreate the test database."
    echo "  -f, --force                 Force a clean re-build of the virtual environment. Useful when dependencies have been added."
    echo "  -u, --update                Update the virtual environment with any     newer package versions"
    echo "  -p, --pep8                  Just run PEP8 and HACKING compliance check"
    echo "  -P, --no-pep8               Don't run static code checks"
    echo "  -c, --coverage              Generate coverage report"
    echo "  -d, --debug                 Run tests with testtools instead of testr. This allows you to use the debugger."
    echo "  -h, --help                  Print this usage message"
    echo "  --hide-elapsed              Don't print the elapsed time for each test along with slow test list"
    echo "  --virtual-env-path <path>   Location of the virtualenv directory."
    echo "                                  Default: \$(pwd)"
    echo "  --virtual-env-name <name>   Name of the virtualenv directory."
    echo "                                  Default: .venv"
    echo "  --tools-path <dir>          Location of the tools directory."
    echo "                                  Default: \$(pwd)"
    echo "  --concurrency <concurrency> How many processes to use when running the tests."
    echo "                                  A value of 0 autodetects concurrency from your CPU count."
    echo "                                  Default: 1"
    echo ""
    echo "Note: with no options specified, the script will try to run the tests in a virtual environment,"
    echo "      If no virtualenv is found, the script will ask if you would like to create one.  If you "
    echo "      prefer to run tests NOT in a virtual environment, simply pass the -N option."
    exit
}

function process_options {
    i=1
    while [ $i -le $# ]; do
        case "${!i}" in
            -h|--help) usage;;
            -V|--virtual-env) always_venv=1; never_venv=0;;
            -N|--no-virtual-env) always_venv=0; never_venv=1;;
            -s|--no-site-packages) no_site_packages=1;;
            -r|--recreate-db) recreate_db=1;;
            -n|--no-recreate-db) recreate_db=0;;
            -f|--force) force=1;;
            -u|--update) update=1;;
            -p|--pep8) just_pep8=1;;
            -P|--no-pep8) no_pep8=1;;
            -c|--coverage) coverage=1;;
            -d|--debug) debug=1;;
            --virtual-env-path)
                (( i++ ))
                venv_path=${!i}
                ;;
            --virtual-env-name)
                (( i++ ))
                venv_dir=${!i}
                ;;
            --tools-path)
                (( i++ ))
                tools_path=${!i}
                ;;
            --concurrency)
                (( i++ ))
                concurrency=${!i}
                ;;
            -*) testropts="$testropts ${!i}";;
            *) testrargs="$testrargs ${!i}"
        esac
        (( i++ ))
    done
}

tool_path=${tools_path:-$(pwd)}
venv_path=${venv_path:-$(pwd)}
venv_dir=${venv_name:-.venv}
with_venv=tools/with_venv.sh
always_venv=0
never_venv=0
force=0
no_site_packages=0
installvenvopts=
testrargs=
testropts=
wrapper=""
just_pep8=0
no_pep8=0
coverage=0
debug=0
recreate_db=1
update=0
concurrency=1

process_options $@
# Make our paths available to other scripts we call
export venv_path
export venv_dir
export venv_name
export tools_dir
export venv=${venv_path}/${venv_dir}

if [ $no_site_packages -eq 1 ]; then
    installvenvopts="--no-site-packages"
fi

function init_testr {
    if [ ! -d .testrepository ]; then
        ${wrapper} testr init
    fi
}

function run_tests {
    # Cleanup *pyc
    ${wrapper} find . -type f -name "*.pyc" -delete

    if [ $debug -eq 1 ]; then
        if [ "$testropts" = "" ] && [ "$testrargs" = "" ]; then
            # Default to running all tests if specific test is not
            # provided.
            testrargs="discover ./manila/tests"
        fi
        ${wrapper} python -m testtools.run $testropts $testrargs

        # Short circuit because all of the testr and coverage stuff
        # below does not make sense when running testtools.run for
        # debugging purposes.
        return $?
    fi

    if [ $coverage -eq 1 ]; then
        TESTRTESTS="$TESTRTESTS --coverage"
    else
        TESTRTESTS="$TESTRTESTS"
    fi

    # Just run the test suites in current environment
    set +e
    testrargs=`echo "$testrargs" | sed -e's/^\s*\(.*\)\s*$/\1/'`
    TESTRTESTS="$TESTRTESTS --testr-args='--subunit --concurrency $concurrency $testropts $testrargs'"
    if [ setup.cfg -nt manila.egg-info/entry_points.txt ]; then
        ${wrapper} python setup.py egg_info
    fi
    echo "Running \`${wrapper} $TESTRTESTS\`"
    if ${wrapper} which subunit-2to1 2>&1 > /dev/null; then
        # subunit-2to1 is present, testr subunit stream should be in version 2
        # format. Convert to version one before colorizing.
        bash -c "${wrapper} $TESTRTESTS | ${wrapper} subunit-2to1 | ${wrapper} tools/colorizer.py"
    else
        bash -c "${wrapper} $TESTRTESTS | ${wrapper} tools/colorizer.py"
    fi
    RESULT=$?
    set -e

    copy_subunit_log

    if [ $coverage -eq 1 ]; then
        echo "Generating coverage report in covhtml/"
        # Don't compute coverage for common code, which is tested elsewhere
        ${wrapper} coverage combine
        ${wrapper} coverage html --include='manila/*' -d covhtml -i
    fi

    return $RESULT
}

function copy_subunit_log {
    LOGNAME=`cat .testrepository/next-stream`
    LOGNAME=$(($LOGNAME - 1))
    LOGNAME=".testrepository/${LOGNAME}"
    cp $LOGNAME subunit.log
}

function run_pep8 {
    echo "Running flake8..."
    bash -c "${wrapper} flake8"
}

TESTRTESTS="python setup.py testr"

if [ $never_venv -eq 0 ]; then
    # Remove the virtual environment if --force used
    if [ $force -eq 1 ]; then
        echo "Cleaning virtualenv..."
        rm -rf ${venv}
    fi
    if [ $update -eq 1 ]; then
        echo "Updating virtualenv..."
        python tools/install_venv.py $installvenvopts
    fi
    if [ -e ${venv} ]; then
        wrapper="${with_venv}"
    else
        if [ $always_venv -eq 1 ]; then
            # Automatically install the virtualenv
            python tools/install_venv.py $installvenvopts
            wrapper="${with_venv}"
        else
            echo -e "No virtual environment found...create one? (Y/n) \c"
            read use_ve
            if [ "x$use_ve" = "xY" -o "x$use_ve" = "x" -o "x$use_ve" = "xy" ]; then
                # Install the virtualenv and run the test suite in it
                python tools/install_venv.py $installvenvopts
                wrapper=${with_venv}
            fi
        fi
    fi
fi

# Delete old coverage data from previous runs
if [ $coverage -eq 1 ]; then
    ${wrapper} coverage erase
fi

if [ $just_pep8 -eq 1 ]; then
    run_pep8
    exit
fi

if [ $recreate_db -eq 1 ]; then
    rm -f tests.sqlite
fi

init_testr
run_tests

# NOTE(sirp): we only want to run pep8 when we're running the full-test suite,
# not when we're running tests individually. To handle this, we need to
# distinguish between options (testropts), which begin with a '-', and
# arguments (testrargs).
if [ -z "$testrargs" ]; then
    if [ $no_pep8 -eq 0 ]; then
        run_pep8
    fi
fi