openstack
/
neutron
Code Issues Proposed changes

Parallelize quantum unit testing: 

This change switches run_tests.sh to use testr
in parallel mode, instead of nosetests, in order
to enable unit tests to run in parallel.

By default, the number of parallel test processes
is set to the number of cores on the test machine.

A similar change was recently merged to nova:
  https://review.openstack.org/#/c/15078/

Some tests required updating to remove inter-testcase
dependencies.

bug #1099694

Change-Id: Idfb923d424342a07dcba88d70b971683f549f763
This commit is contained in:
Tim Miller 2013-03-10 15:23:46 -07:00
parent bea61bf94e
commit 147038a613
5 changed files with 178 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
quantum/tests/unit/cisco/test_nexus_plugin.py
View File

@ -84,17 +84,9 @@ class TestCiscoNexusPlugin(base.BaseTestCase):
self.addCleanup(self.patch_obj.stop) self.addCleanup(self.patch_obj.stop)
def test_a_create_network(self): def test_create_networks(self):
""" """
Tests creation of two new Virtual Network. Tests creation of two new Virtual Networks.
Tests deletion of one Virtual Network.
This would result the following -
The Nexus device should have only one network
vlan configured on it's plugin configured
interfaces.
If running this test individually, run
test_nexus_clear_vlan after this test to clean
up the second vlan created by this test.
""" """
tenant_id = self.tenant_id tenant_id = self.tenant_id
net_name = self.net_name net_name = self.net_name
@ -125,14 +117,15 @@ class TestCiscoNexusPlugin(base.BaseTestCase):
self.second_vlan_name) self.second_vlan_name)
self.assertEqual(new_net_dict[const.NET_VLAN_ID], self.second_vlan_id) self.assertEqual(new_net_dict[const.NET_VLAN_ID], self.second_vlan_id)
def test_b_nexus_delete_port(self): def test_nexus_delete_port(self):
""" """
Test to clean up second vlan of nexus device Test deletion of a vlan.
created by test_create_delete_network. This
test will fail if it is run individually.
""" """
self._cisco_nexus_plugin.create_network(
self.tenant_id, self.net_name, self.net_id, self.vlan_name,
self.vlan_id, self._hostname, INSTANCE)
expected_instance_id = self._cisco_nexus_plugin.delete_port( expected_instance_id = self._cisco_nexus_plugin.delete_port(
INSTANCE, self.second_vlan_id INSTANCE, self.vlan_id)
)
self.assertEqual(expected_instance_id, INSTANCE) self.assertEqual(expected_instance_id, INSTANCE)

11
quantum/tests/unit/openvswitch/test_ovs_tunnel.py
View File

@ -297,12 +297,23 @@ class TunnelTest(base.BaseTestCase):
self.mox.VerifyAll() self.mox.VerifyAll()
def testPortUnbound(self): def testPortUnbound(self):
self.mock_int_bridge.set_db_attribute('Port', VIF_PORT.port_name,
'tag', str(LVM.vlan))
self.mock_int_bridge.delete_flows(in_port=VIF_PORT.ofport)
action_string = 'mod_vlan_vid:%s,normal' % LV_ID
self.mock_tun_bridge.add_flow(priority=3, tun_id=LS_ID,
dl_dst=VIF_PORT.vif_mac,
actions=action_string)
self.mock_tun_bridge.delete_flows(dl_dst=VIF_MAC, tun_id=LS_ID) self.mock_tun_bridge.delete_flows(dl_dst=VIF_MAC, tun_id=LS_ID)
self.mox.ReplayAll() self.mox.ReplayAll()
a = ovs_quantum_agent.OVSQuantumAgent(self.INT_BRIDGE, a = ovs_quantum_agent.OVSQuantumAgent(self.INT_BRIDGE,
self.TUN_BRIDGE, self.TUN_BRIDGE,
'10.0.0.1', self.NET_MAPPING, '10.0.0.1', self.NET_MAPPING,
'sudo', 2, True) 'sudo', 2, True)
a.local_vlan_map[NET_UUID] = LVM
a.port_bound(VIF_PORT, NET_UUID, 'gre', None, LS_ID)
a.available_local_vlans = set([LV_ID]) a.available_local_vlans = set([LV_ID])
a.local_vlan_map[NET_UUID] = LVM a.local_vlan_map[NET_UUID] = LVM
a.port_unbound(VIF_ID, NET_UUID) a.port_unbound(VIF_ID, NET_UUID)

5
quantum/tests/unit/test_l3_plugin.py
View File

@ -645,6 +645,7 @@ class L3NatDBTestCase(L3NatTestCaseBase):
'subnet.create.end', 'subnet.create.end',
'router.interface.create', 'router.interface.create',
'router.interface.delete'] 'router.interface.delete']
test_notifier.NOTIFICATIONS = []
with self.router() as r: with self.router() as r:
with self.subnet() as s: with self.subnet() as s:
body = self._router_interface_action('add', body = self._router_interface_action('add',
@ -666,8 +667,8 @@ class L3NatDBTestCase(L3NatTestCaseBase):
expected_code=exc.HTTPNotFound.code) expected_code=exc.HTTPNotFound.code)
self.assertEqual( self.assertEqual(
set(n['event_type'] for n in test_notifier.NOTIFICATIONS), set(exp_notifications),
set(exp_notifications)) set(n['event_type'] for n in test_notifier.NOTIFICATIONS))
def test_router_add_interface_subnet_with_bad_tenant_returns_404(self): def test_router_add_interface_subnet_with_bad_tenant_returns_404(self):
with mock.patch('quantum.context.Context.to_dict') as tdict: with mock.patch('quantum.context.Context.to_dict') as tdict:

248
run_tests.sh
View File

@ -1,19 +1,30 @@
#!/bin/bash #!/bin/bash
set -eu
function usage { function usage {
echo "Usage: $0 [OPTION]..." echo "Usage: $0 [OPTION]..."
echo "Run Quantum's test suite(s)" echo "Run Quantum's test suite(s)"
echo "" echo ""
echo " -V, --virtual-env Always use virtualenv. Install automatically if not present" 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 " -N, --no-virtual-env Don't use virtualenv. Run tests in local environment"
echo " -c, --coverage Generate coverage report" echo " -s, --no-site-packages Isolate the virtualenv from the global Python environment"
echo " -f, --force Force a clean re-build of the virtual environment. Useful when dependencies have been added." echo " -r, --recreate-db Recreate the test database (deprecated, as this is now the default)."
echo " -u, --update Update the virtual environment with any newer package versions" echo " -n, --no-recreate-db Don't recreate the test database."
echo " -p, --pep8 Just run pep8" echo " -f, --force Force a clean re-build of the virtual environment. Useful when dependencies have been added."
echo " -P, --no-pep8 Don't run pep8" echo " -u, --update Update the virtual environment with any newer package versions"
echo " -l, --pylint Just run pylint" echo " -p, --pep8 Just run PEP8 and HACKING compliance check"
echo " -v, --verbose Run verbose pylint analysis" echo " -P, --no-pep8 Don't run static code checks"
echo " -h, --help Print this usage message" 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 "" echo ""
echo "Note: with no options specified, the script will try to run the tests in a virtual environment," 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 " If no virtualenv is found, the script will ask if you would like to create one. If you "
@ -21,103 +32,147 @@ function usage {
exit exit
} }
function process_option { function process_options {
case "$1" in i=1
-h|--help) usage;; while [ $i -le $# ]; do
-V|--virtual-env) let always_venv=1; let never_venv=0;; case "${!i}" in
-N|--no-virtual-env) let always_venv=0; let never_venv=1;; -h|--help) usage;;
-f|--force) let force=1;; -V|--virtual-env) always_venv=1; never_venv=0;;
-u|--update) update=1;; -N|--no-virtual-env) always_venv=0; never_venv=1;;
-p|--pep8) let just_pep8=1;; -s|--no-site-packages) no_site_packages=1;;
-P|--no-pep8) no_pep8=1;; -r|--recreate-db) recreate_db=1;;
-l|--pylint) let just_pylint=1; let never_venv=1; let always_venv=0;; -n|--no-recreate-db) recreate_db=0;;
-c|--coverage) coverage=1;; -f|--force) force=1;;
-v|--verbose) verbose=1;; -u|--update) update=1;;
-*) noseopts="$noseopts $1";; -p|--pep8) just_pep8=1;;
*) noseargs="$noseargs $1" -P|--no-pep8) no_pep8=1;;
esac -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}
;;
-*) testropts="$testropts ${!i}";;
*) testrargs="$testrargs ${!i}"
esac
(( i++ ))
done
} }
venv=.venv tool_path=${tools_path:-$(pwd)}
venv_path=${venv_path:-$(pwd)}
venv_dir=${venv_name:-.venv}
with_venv=tools/with_venv.sh with_venv=tools/with_venv.sh
always_venv=0 always_venv=0
never_venv=0 never_venv=0
force=0
no_site_packages=0
installvenvopts=
testrargs=
testropts=
wrapper=""
just_pep8=0 just_pep8=0
no_pep8=0 no_pep8=0
just_pylint=0
force=0
noseargs=
wrapper=""
coverage=0 coverage=0
verbose=0 debug=0
recreate_db=1
update=0 update=0
for arg in "$@"; do LANG=en_US.UTF-8
process_option $arg LANGUAGE=en_US:en
done LC_ALL=C
# If enabled, tell nose to collect coverage data process_options $@
if [ $coverage -eq 1 ]; then # Make our paths available to other scripts we call
noseopts="$noseopts --with-coverage --cover-package=quantum" 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 fi
function init_testr {
if [ ! -d .testrepository ]; then
${wrapper} testr init
fi
}
function run_tests { function run_tests {
# Just run the test suites in current environment # Cleanup *pyc
${wrapper} rm -f ./$PLUGIN_DIR/tests.sqlite ${wrapper} find . -type f -name "*.pyc" -delete
if [ $verbose -eq 1 ]; then
${wrapper} $NOSETESTS if [ $debug -eq 1 ]; then
else if [ "$testropts" = "" ] && [ "$testrargs" = "" ]; then
${wrapper} $NOSETESTS 2> run_tests.log # Default to running all tests if specific test is not
fi # provided.
# If we get some short import error right away, print the error log directly testrargs="discover ./quantum/tests"
RESULT=$?
if [ "$RESULT" -ne "0" ];
then
ERRSIZE=`wc -l run_tests.log | awk '{print \$1}'`
if [ $verbose -eq 0 -a "$ERRSIZE" -lt "40" ];
then
cat run_tests.log
fi 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 fi
if [ $coverage -eq 1 ]; then
TESTRTESTS="$TESTRTESTS --coverage"
else
TESTRTESTS="$TESTRTESTS --slowest"
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 $testropts $testrargs'"
echo "Running \`${wrapper} $TESTRTESTS\`"
bash -c "${wrapper} $TESTRTESTS | ${wrapper} subunit2pyunit"
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='quantum/*' --omit='quantum/openstack/common/*' -d covhtml -i
fi
return $RESULT return $RESULT
} }
function run_pylint { function copy_subunit_log {
echo "Running pylint ..." LOGNAME=`cat .testrepository/next-stream`
PYLINT_OPTIONS="--rcfile=.pylintrc --output-format=parseable" LOGNAME=$(($LOGNAME - 1))
PYLINT_INCLUDE="quantum" LOGNAME=".testrepository/${LOGNAME}"
OLD_PYTHONPATH=$PYTHONPATH cp $LOGNAME subunit.log
export PYTHONPATH=$PYTHONPATH:.quantum:./client/lib/quantum:./common/lib/quantum
BASE_CMD="pylint $PYLINT_OPTIONS $PYLINT_INCLUDE"
[ $verbose -eq 1 ] && $BASE_CMD || msg_count=`$BASE_CMD | grep 'quantum/' | wc -l`
if [ $verbose -eq 0 ]; then
echo "Pylint messages count: " $msg_count
fi
export PYTHONPATH=$OLD_PYTHONPATH
} }
function run_pep8 { function run_pep8 {
echo "Running pep8 ..." echo "Running pep8 ..."
PEP8_EXCLUDE="vcsversion.py,*.pyc,openstack" PEP8_EXCLUDE="vcsversion.py,*.pyc,openstack"
# we now turn off pep8 1.3 E125 check to avoid make change to # we now turn off pep8 1.3 E125 check to avoid make change to
# openstack-common . # openstack-common .
PEP8_OPTIONS="--exclude=$PEP8_EXCLUDE --ignore=E125,E711,E712 --repeat --show-source" PEP8_OPTIONS="--exclude=$PEP8_EXCLUDE --ignore=E125,E711,E712 --repeat --show"
PEP8_INCLUDE="bin/* quantum run_tests.py setup*.py" PEP8_INCLUDE="bin/* quantum run_tests.py setup*.py"
${wrapper} pep8 $PEP8_OPTIONS $PEP8_INCLUDE ${wrapper} pep8 $PEP8_OPTIONS $PEP8_INCLUDE
} }
NOSETESTS="python ./$PLUGIN_DIR/run_tests.py $noseopts $noseargs"
if [ -n "$PLUGIN_DIR" ] TESTRTESTS="python setup.py testr"
then
if ! [ -f ./$PLUGIN_DIR/run_tests.py ]
then
echo "Could not find run_tests.py in plugin directory $PLUGIN_DIR"
exit 1
fi
fi
if [ $never_venv -eq 0 ] if [ $never_venv -eq 0 ]
then then
@ -127,22 +182,22 @@ then
rm -rf ${venv} rm -rf ${venv}
fi fi
if [ $update -eq 1 ]; then if [ $update -eq 1 ]; then
echo "Updating virtualenv..." echo "Updating virtualenv..."
python tools/install_venv.py python tools/install_venv.py $installvenvopts
fi fi
if [ -e ${venv} ]; then if [ -e ${venv} ]; then
wrapper="${with_venv}" wrapper="${with_venv}"
else else
if [ $always_venv -eq 1 ]; then if [ $always_venv -eq 1 ]; then
# Automatically install the virtualenv # Automatically install the virtualenv
python tools/install_venv.py python tools/install_venv.py $installvenvopts
wrapper="${with_venv}" wrapper="${with_venv}"
else else
echo -e "No virtual environment found...create one? (Y/n) \c" echo -e "No virtual environment found...create one? (Y/n) \c"
read use_ve read use_ve
if [ "x$use_ve" = "xY" -o "x$use_ve" = "x" -o "x$use_ve" = "xy" ]; then 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 # Install the virtualenv and run the test suite in it
python tools/install_venv.py python tools/install_venv.py $installvenvopts
wrapper=${with_venv} wrapper=${with_venv}
fi fi
fi fi
@ -158,23 +213,20 @@ if [ $just_pep8 -eq 1 ]; then
run_pep8 run_pep8
exit exit
fi fi
if [ $just_pylint -eq 1 ]; then
run_pylint if [ $recreate_db -eq 1 ]; then
exit rm -f tests.sqlite
fi fi
RV=0 init_testr
if [ $no_pep8 -eq 1 ]; then run_tests
run_tests
RV=$? # NOTE(sirp): we only want to run pep8 when we're running the full-test suite,
else # not when we're running tests individually. To handle this, we need to
run_tests && run_pep8 || RV=1 # 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 fi
if [ $coverage -eq 1 ]; then
echo "Generating coverage report in covhtml/"
${wrapper} coverage html -d covhtml -i
fi
exit $RV

7
tox.ini
View File

@ -14,7 +14,7 @@ deps = -r{toxinidir}/tools/pip-requires
setuptools_git>=0.4 setuptools_git>=0.4
commands = commands =
python tools/patch_tox_venv.py python tools/patch_tox_venv.py
nosetests {posargs} python setup.py testr --slowest --testr-args='{posargs}'
[tox:jenkins] [tox:jenkins]
sitepackages = True sitepackages = True
@ -33,8 +33,11 @@ commands =
commands = python ./tools/check_i18n.py ./quantum ./tools/i18n_cfg.py commands = python ./tools/check_i18n.py ./quantum ./tools/i18n_cfg.py
[testenv:cover] [testenv:cover]
# Also do not run test_coverage_ext tests while gathering coverage as those
# tests conflict with coverage.
setenv = VIRTUAL_ENV={envdir} setenv = VIRTUAL_ENV={envdir}
NOSE_WITH_COVERAGE=1 commands =
python setup.py testr --coverage
[testenv:venv] [testenv:venv]
commands = {posargs} commands = {posargs}