From 16a04df3d0da5d6f51b7572c9fe2794c0bd718c1 Mon Sep 17 00:00:00 2001 From: vponomaryov Date: Wed, 16 Jul 2014 13:23:05 +0300 Subject: [PATCH] Refactor test framework Manila's test framework is pretty old and requires update. Changes: - usage of nose replaced with testr - now all the tests are thread safe - added new options for run_tests.sh, such as --concurrency, --debug, etc... - new '--concurrency' option for run_tests.sh defaults to 1, examples: ./run_tests.sh # will run in 1 thread ./run_tests.sh --concurrency 2 # will run tests in 2 threads - added tools/colorizer.py for colorizing output of testrun with run_tests.sh - tests running with tox use as much threads as cores available by default - examples of testrun with tox: tox # will run test suites defined with 'envlist' in tox.ini, now it is pep8,py26,py27 tox -epy27 # amount of threads is equal to amount of cores tox -epy27 -- --concurrency=2 # amount of threads is 2 tox -epy27 -- --concurrency=4 # amount of threads is 4 - Added 'Database' class to manila.test module, for more conveniant db testing - updated policy file 'manila/tests/policy.json' to allow share-network actions - removed nose-related requirements - added new requirements for testrepository, subunit With merge of this change all old installed virtual environments become incompatible and should be removed with "rm -rf .tox .venv" before testrun. Implements blueprint testr-with-unittests Change-Id: I9579ecd538e29d478dbc12adc7dcc33fc668b397 --- .gitignore | 1 + .testr.conf | 7 + HACKING.rst | 10 + manila/api/openstack/__init__.py | 7 +- manila/test.py | 60 +++++- manila/tests/__init__.py | 44 ---- manila/tests/policy.json | 6 + manila/tests/test_share_rpcapi.py | 2 +- run_tests.sh | 226 ++++++++++++-------- setup.cfg | 8 - test-requirements.txt | 7 +- tools/colorizer.py | 332 ++++++++++++++++++++++++++++++ tools/with_venv.sh | 9 +- tox.ini | 27 ++- 14 files changed, 584 insertions(+), 162 deletions(-) create mode 100644 .testr.conf create mode 100755 tools/colorizer.py diff --git a/.gitignore b/.gitignore index 18a8db348d..a27388a890 100644 --- a/.gitignore +++ b/.gitignore @@ -24,6 +24,7 @@ instances keeper keys local_settings.py +subunit.log tools/conf/manila.conf* tools/lintstack.head.py tools/pylint_exceptions diff --git a/.testr.conf b/.testr.conf new file mode 100644 index 0000000000..d863a3edcc --- /dev/null +++ b/.testr.conf @@ -0,0 +1,7 @@ +[DEFAULT] +test_command=OS_STDOUT_CAPTURE=${OS_STDOUT_CAPTURE:-1} \ + OS_STDERR_CAPTURE=${OS_STDERR_CAPTURE:-1} \ + OS_TEST_TIMEOUT=${OS_TEST_TIMEOUT:-60} \ + ${PYTHON:-python} -m subunit.run discover -t ./ ./manila/tests $LISTOPT $IDOPTION +test_id_option=--load-list $IDFILE +test_list_option=--list diff --git a/HACKING.rst b/HACKING.rst index a718c6e934..2a895938b4 100644 --- a/HACKING.rst +++ b/HACKING.rst @@ -233,6 +233,16 @@ The copy of the code should never be directly modified here. Please always update openstack-common first and then run the script to copy the changes across. + +Running Tests +------------- +The testing system is based on a combination of tox and testr. If you just +want to run the whole suite, run `tox` and all will be fine. However, if +you'd like to dig in a bit more, you might want to learn some things about +testr itself. A basic walkthrough for OpenStack can be found at +http://wiki.openstack.org/testr + + OpenStack Trademark ------------------- diff --git a/manila/api/openstack/__init__.py b/manila/api/openstack/__init__.py index f96b50b496..fb38c802dc 100644 --- a/manila/api/openstack/__init__.py +++ b/manila/api/openstack/__init__.py @@ -20,7 +20,6 @@ WSGI middleware for OpenStack API controllers. import routes -from manila.api.middleware import fault from manila.api.openstack import wsgi from manila.openstack.common import log as logging from manila import utils @@ -123,8 +122,10 @@ class APIRouter(base_wsgi.Router): raise NotImplementedError -class FaultWrapper(fault.FaultWrapper): +class FaultWrapper(base_wsgi.Middleware): def __init__(self, application): LOG.warn(_('manila.api.openstack:FaultWrapper is deprecated. Please ' 'use manila.api.middleware.fault:FaultWrapper instead.')) - super(FaultWrapper, self).__init__(application) + # Avoid circular imports from here. + from manila.api.middleware import fault + super(FaultWrapper, self).__init__(fault.FaultWrapper(application)) diff --git a/manila/test.py b/manila/test.py index 3c83374ffd..c99ba2d348 100644 --- a/manila/test.py +++ b/manila/test.py @@ -22,14 +22,19 @@ inline callbacks. """ import functools +import os +import shutil import uuid +import fixtures import mock from oslo.config import cfg from oslo.messaging import conffixture as messaging_conffixture import six import testtools +from manila.db import migration +from manila.db.sqlalchemy import session as sqla_session from manila.openstack.common import importutils from manila.openstack.common import log as logging from manila.openstack.common import timeutils @@ -52,6 +57,47 @@ CONF.register_opts(test_opts) LOG = logging.getLogger(__name__) +_DB_CACHE = None + + +class Database(fixtures.Fixture): + + def __init__(self, db_session, db_migrate, sql_connection, sqlite_db, + sqlite_clean_db): + self.sql_connection = sql_connection + self.sqlite_db = sqlite_db + self.sqlite_clean_db = sqlite_clean_db + self.engine = db_session.get_engine() + self.engine.dispose() + conn = self.engine.connect() + if sql_connection == "sqlite://": + if db_migrate.db_version() > db_migrate.INIT_VERSION: + return + else: + testdb = os.path.join(CONF.state_path, sqlite_db) + if os.path.exists(testdb): + return + db_migrate.db_sync() + if sql_connection == "sqlite://": + conn = self.engine.connect() + self._DB = "".join(line for line in conn.connection.iterdump()) + self.engine.dispose() + else: + cleandb = os.path.join(CONF.state_path, sqlite_clean_db) + shutil.copyfile(testdb, cleandb) + + def setUp(self): + super(Database, self).setUp() + if self.sql_connection == "sqlite://": + conn = self.engine.connect() + conn.connection.executescript(self._DB) + self.addCleanup(self.engine.dispose) # pylint: disable=E1101 + else: + shutil.copyfile( + os.path.join(CONF.state_path, self.sqlite_clean_db), + os.path.join(CONF.state_path, self.sqlite_db), + ) + class StubOutForTesting(object): def __init__(self, parent): @@ -77,7 +123,19 @@ class TestCase(testtools.TestCase): # now that we have some required db setup for the system # to work properly. self.start = timeutils.utcnow() - tests.reset_db() + + self.log_fixture = self.useFixture(fixtures.FakeLogger()) + + global _DB_CACHE + if not _DB_CACHE: + _DB_CACHE = Database( + sqla_session, + migration, + sql_connection=CONF.sql_connection, + sqlite_db=CONF.sqlite_db, + sqlite_clean_db=CONF.sqlite_clean_db, + ) + self.useFixture(_DB_CACHE) self.stubs = StubOutForTesting(self) self.injected = [] diff --git a/manila/tests/__init__.py b/manila/tests/__init__.py index 760bad6e71..3b8468ac01 100644 --- a/manila/tests/__init__.py +++ b/manila/tests/__init__.py @@ -30,52 +30,8 @@ import eventlet eventlet.monkey_patch() -from oslo.config import cfg # See http://code.google.com/p/python-nose/issues/detail?id=373 # The code below enables nosetests to work with i18n _() blocks import __builtin__ setattr(__builtin__, '_', lambda x: x) -import os -import shutil - -from manila.db import migration -from manila.db.sqlalchemy.session import get_engine -from manila.tests import conf_fixture - - -CONF = cfg.CONF - -_DB = None - - -def reset_db(): - if CONF.sql_connection == "sqlite://": - engine = get_engine() - engine.dispose() - conn = engine.connect() - conn.connection.executescript(_DB) - else: - shutil.copyfile(os.path.join(CONF.state_path, CONF.sqlite_clean_db), - os.path.join(CONF.state_path, CONF.sqlite_db)) - - -def setup(): - conf_fixture.set_defaults(CONF) - if CONF.sql_connection == "sqlite://": - if migration.db_version() > 1: - return - else: - testdb = os.path.join(CONF.state_path, CONF.sqlite_db) - if os.path.exists(testdb): - return - migration.db_sync() - - if CONF.sql_connection == "sqlite://": - global _DB - engine = get_engine() - conn = engine.connect() - _DB = "".join(line for line in conn.connection.iterdump()) - else: - cleandb = os.path.join(CONF.state_path, CONF.sqlite_clean_db) - shutil.copyfile(testdb, cleandb) diff --git a/manila/tests/policy.json b/manila/tests/policy.json index 25f97e4f50..59f09c60c4 100644 --- a/manila/tests/policy.json +++ b/manila/tests/policy.json @@ -13,6 +13,12 @@ "share:get_snapshot": [], "share:get_all_snapshots": [], + "share_network:create": [], + "share_network:index": [], + "share_network:show": [], + "share_network:update": [], + "share_network:delete": [], + "share_server:index": [["rule:admin_api"]], "share_server:show": [["rule:admin_api"]], "share_server:details": [["rule:admin_api"]], diff --git a/manila/tests/test_share_rpcapi.py b/manila/tests/test_share_rpcapi.py index 9bbf4b328c..7dd3fe0ce2 100644 --- a/manila/tests/test_share_rpcapi.py +++ b/manila/tests/test_share_rpcapi.py @@ -33,6 +33,7 @@ CONF = cfg.CONF class ShareRpcAPITestCase(test.TestCase): def setUp(self): + super(ShareRpcAPITestCase, self).setUp() self.context = context.get_admin_context() shr = {} shr['host'] = 'fake_host' @@ -53,7 +54,6 @@ class ShareRpcAPITestCase(test.TestCase): self.fake_access = jsonutils.to_primitive(access) self.fake_snapshot = jsonutils.to_primitive(snapshot) self.fake_share_server = jsonutils.to_primitive(share_server) - super(ShareRpcAPITestCase, self).setUp() self.ctxt = context.RequestContext('fake_user', 'fake_project') self.rpcapi = share_rpcapi.ShareAPI() diff --git a/run_tests.sh b/run_tests.sh index ee3c63f78f..fb9d052853 100755 --- a/run_tests.sh +++ b/run_tests.sh @@ -1,25 +1,33 @@ #!/bin/bash -set -u +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 " -x, --stop Stop running tests after the first error or failure." - 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 " -X, --coverage-xml Generate XML coverage report." - 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 " -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 Location of the virtualenv directory." + echo " Default: \$(pwd)" + echo " --virtual-env-name Name of the virtualenv directory." + echo " Default: .venv" + echo " --tools-path Location of the tools directory." + echo " Default: \$(pwd)" + echo " --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 " @@ -27,94 +35,152 @@ function usage { exit } -function process_option { - case "$1" 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;; - -m|--patch-migrate) patch_migrate=1;; - -w|--no-patch-migrate) patch_migrate=0;; - -f|--force) force=1;; - -u|--update) update=1;; - -p|--pep8) just_pep8=1;; - -P|--no-pep8) no_pep8=1;; - -c|--coverage) coverage=1;; - -X|--coverage-xml) coverage_xml=1;; - -*) noseopts="$noseopts $1";; - *) noseargs="$noseargs $1" - esac +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 } -venv=.venv +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= -noseargs= -noseopts= +testrargs= +testropts= wrapper="" just_pep8=0 no_pep8=0 coverage=0 -coverage_xml=0 +debug=0 recreate_db=1 -patch_migrate=1 update=0 +concurrency=1 -export NOSE_WITH_OPENSTACK=true -export NOSE_OPENSTACK_COLOR=true -export NOSE_OPENSTACK_SHOW_ELAPSED=true - -for arg in "$@"; do - process_option $arg -done - -# If enabled, tell nose to collect coverage data -if [ $coverage -eq 1 ]; then - noseopts="$noseopts --with-coverage --cover-package=manila" -fi -if [ $coverage_xml -eq 1 ]; then - noseopts="$noseopts --with-xcoverage --cover-package=manila --xcoverage-file=`pwd`/coverage.xml" -fi +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 - ${wrapper} $NOSETESTS + 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/*' --omit='manila/openstack/common/*' -d covhtml -i + fi + return $RESULT } -# Files of interest -# NOTE(lzyeval): Avoid selecting manila-api-paste.ini and manila.conf in manila/bin -# when running on devstack. -# NOTE(lzyeval): Avoid selecting *.pyc files to reduce pep8 check-up time -# when running on devstack. -# NOTE(dprince): Exclude xenapi plugins. They are Python 2.4 code and as such -# cannot be expected to work with tools/hacking checks. -xen_net_path="plugins/xenserver/networking/etc/xensource/scripts" -srcfiles=`find manila -type f -name "*.py" ! -path "manila/openstack/common/*"` -srcfiles+=" `find bin -type f ! -name "manila.conf*" ! -name "*api-paste.ini*"`" -srcfiles+=" `find tools -type f -name "*.py"`" -srcfiles+=" setup.py" - -function run_pep8 { - echo "Running PEP8 and HACKING compliance check..." - bash -c "${wrapper} flake8 manila* bin" +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" +} -NOSETESTS="nosetests $noseopts $noseargs" +TESTRTESTS="python -m manila.openstack.common.lockutils python setup.py testr" if [ $never_venv -eq 0 ] then @@ -160,23 +226,15 @@ if [ $recreate_db -eq 1 ]; then rm -f tests.sqlite fi +init_testr run_tests -RET=$? # 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 (noseopts), which begin with a '-', and -# arguments (noseargs). -if [ -z "$noseargs" ]; then +# 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 - -if [ $coverage -eq 1 ]; then - echo "Generating coverage report in covhtml/" - # Don't compute coverage for common code, which is tested elsewhere - ${wrapper} coverage html --include='manila/*' --omit='manila/openstack/common/*' -d covhtml -i -fi - -exit $RET diff --git a/setup.cfg b/setup.cfg index 50df67fa5a..df8b3a893d 100644 --- a/setup.cfg +++ b/setup.cfg @@ -76,13 +76,5 @@ keywords = _ gettext ngettext l_ lazy_gettext mapping_file = babel.cfg output_file = manila/locale/manila.pot -[nosetests] -tests=manila/tests -cover-package = manila -cover-erase = true -cover-inclusive = true -verbosity=2 -detailed-errors=1 - [wheel] universal = 1 diff --git a/test-requirements.txt b/test-requirements.txt index cbd78d1a34..5ddca37345 100644 --- a/test-requirements.txt +++ b/test-requirements.txt @@ -1,13 +1,12 @@ hacking>=0.9.2,<0.10 coverage>=3.6 +discover fixtures>=0.3.14 mock>=1.0 MySQL-python -nose -nosehtmloutput>=0.0.3 -nosexcover -openstack.nose_plugin>=0.7 psycopg2 +python-subunit sphinx>=1.1.2,!=1.2.0,<1.3 +testrepository>=0.0.18 testtools>=0.9.34 diff --git a/tools/colorizer.py b/tools/colorizer.py new file mode 100755 index 0000000000..f242c4d510 --- /dev/null +++ b/tools/colorizer.py @@ -0,0 +1,332 @@ +#!/usr/bin/env python +# Copyright (c) 2013, Nebula, Inc. +# Copyright 2010 United States Government as represented by the +# Administrator of the National Aeronautics and Space Administration. +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# +# Colorizer Code is borrowed from Twisted: +# Copyright (c) 2001-2010 Twisted Matrix Laboratories. +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +"""Display a subunit stream through a colorized unittest test runner.""" + +import heapq +import sys +import unittest + +import subunit +import testtools + + +class _AnsiColorizer(object): + """ANSI colorizer that wraps a stream object. + + colorizer is an object that loosely wraps around a stream, allowing + callers to write text to the stream in a particular color. + + Colorizer classes must implement C{supported()} and C{write(text, color)}. + """ + _colors = dict(black=30, red=31, green=32, yellow=33, + blue=34, magenta=35, cyan=36, white=37) + + def __init__(self, stream): + self.stream = stream + + def supported(cls, stream=sys.stdout): + """Check if platform is supported. + + A class method that returns True if the current platform supports + coloring terminal output using this method. + + Returns False otherwise. + """ + if not stream.isatty(): + return False # auto color only on TTYs + try: + import curses + except ImportError: + return False + else: + try: + try: + return curses.tigetnum("colors") > 2 + except curses.error: + curses.setupterm() + return curses.tigetnum("colors") > 2 + except Exception: + # guess false in case of error + return False + supported = classmethod(supported) + + def write(self, text, color): + """Write the given text to the stream in the given color. + + @param text: Text to be written to the stream. + + @param color: A string label for a color. e.g. 'red', 'white'. + """ + color = self._colors[color] + self.stream.write('\x1b[%s;1m%s\x1b[0m' % (color, text)) + + +class _Win32Colorizer(object): + """See _AnsiColorizer docstring.""" + def __init__(self, stream): + import win32console + red, green, blue, bold = (win32console.FOREGROUND_RED, + win32console.FOREGROUND_GREEN, + win32console.FOREGROUND_BLUE, + win32console.FOREGROUND_INTENSITY) + self.stream = stream + self.screenBuffer = win32console.GetStdHandle( + win32console.STD_OUT_HANDLE) + self._colors = { + 'normal': red | green | blue, + 'red': red | bold, + 'green': green | bold, + 'blue': blue | bold, + 'yellow': red | green | bold, + 'magenta': red | blue | bold, + 'cyan': green | blue | bold, + 'white': red | green | blue | bold + } + + def supported(cls, stream=sys.stdout): + try: + import win32console + screenBuffer = win32console.GetStdHandle( + win32console.STD_OUT_HANDLE) + except ImportError: + return False + import pywintypes + try: + screenBuffer.SetConsoleTextAttribute( + win32console.FOREGROUND_RED | + win32console.FOREGROUND_GREEN | + win32console.FOREGROUND_BLUE) + except pywintypes.error: + return False + else: + return True + supported = classmethod(supported) + + def write(self, text, color): + color = self._colors[color] + self.screenBuffer.SetConsoleTextAttribute(color) + self.stream.write(text) + self.screenBuffer.SetConsoleTextAttribute(self._colors['normal']) + + +class _NullColorizer(object): + """See _AnsiColorizer docstring.""" + def __init__(self, stream): + self.stream = stream + + def supported(cls, stream=sys.stdout): + return True + supported = classmethod(supported) + + def write(self, text, color): + self.stream.write(text) + + +def get_elapsed_time_color(elapsed_time): + if elapsed_time > 1.0: + return 'red' + elif elapsed_time > 0.25: + return 'yellow' + else: + return 'green' + + +class ManilaTestResult(testtools.TestResult): + def __init__(self, stream, descriptions, verbosity): + super(ManilaTestResult, self).__init__() + self.stream = stream + self.showAll = verbosity > 1 + self.num_slow_tests = 10 + self.slow_tests = [] # this is a fixed-sized heap + self.colorizer = None + # NOTE(vish): reset stdout for the terminal check + stdout = sys.stdout + sys.stdout = sys.__stdout__ + for colorizer in [_Win32Colorizer, _AnsiColorizer, _NullColorizer]: + if colorizer.supported(): + self.colorizer = colorizer(self.stream) + break + sys.stdout = stdout + self.start_time = None + self.last_time = {} + self.results = {} + self.last_written = None + + def _writeElapsedTime(self, elapsed): + color = get_elapsed_time_color(elapsed) + self.colorizer.write(" %.2f" % elapsed, color) + + def _addResult(self, test, *args): + try: + name = test.id() + except AttributeError: + name = 'Unknown.unknown' + test_class, test_name = name.rsplit('.', 1) + + elapsed = (self._now() - self.start_time).total_seconds() + item = (elapsed, test_class, test_name) + if len(self.slow_tests) >= self.num_slow_tests: + heapq.heappushpop(self.slow_tests, item) + else: + heapq.heappush(self.slow_tests, item) + + self.results.setdefault(test_class, []) + self.results[test_class].append((test_name, elapsed) + args) + self.last_time[test_class] = self._now() + self.writeTests() + + def _writeResult(self, test_name, elapsed, long_result, color, + short_result, success): + if self.showAll: + self.stream.write(' %s' % str(test_name).ljust(66)) + self.colorizer.write(long_result, color) + if success: + self._writeElapsedTime(elapsed) + self.stream.writeln() + else: + self.colorizer.write(short_result, color) + + def addSuccess(self, test): + super(ManilaTestResult, self).addSuccess(test) + self._addResult(test, 'OK', 'green', '.', True) + + def addFailure(self, test, err): + if test.id() == 'process-returncode': + return + super(ManilaTestResult, self).addFailure(test, err) + self._addResult(test, 'FAIL', 'red', 'F', False) + + def addError(self, test, err): + super(ManilaTestResult, self).addFailure(test, err) + self._addResult(test, 'ERROR', 'red', 'E', False) + + def addSkip(self, test, reason=None, details=None): + super(ManilaTestResult, self).addSkip(test, reason, details) + self._addResult(test, 'SKIP', 'blue', 'S', True) + + def startTest(self, test): + self.start_time = self._now() + super(ManilaTestResult, self).startTest(test) + + def writeTestCase(self, cls): + if not self.results.get(cls): + return + if cls != self.last_written: + self.colorizer.write(cls, 'white') + self.stream.writeln() + for result in self.results[cls]: + self._writeResult(*result) + del self.results[cls] + self.stream.flush() + self.last_written = cls + + def writeTests(self): + time = self.last_time.get(self.last_written, self._now()) + if not self.last_written or (self._now() - time).total_seconds() > 2.0: + diff = 3.0 + while diff > 2.0: + classes = self.results.keys() + oldest = min(classes, key=lambda x: self.last_time[x]) + diff = (self._now() - self.last_time[oldest]).total_seconds() + self.writeTestCase(oldest) + else: + self.writeTestCase(self.last_written) + + def done(self): + self.stopTestRun() + + def stopTestRun(self): + for cls in list(self.results.iterkeys()): + self.writeTestCase(cls) + self.stream.writeln() + self.writeSlowTests() + + def writeSlowTests(self): + # Pare out 'fast' tests + slow_tests = [item for item in self.slow_tests + if get_elapsed_time_color(item[0]) != 'green'] + if slow_tests: + slow_total_time = sum(item[0] for item in slow_tests) + slow = ("Slowest %i tests took %.2f secs:" + % (len(slow_tests), slow_total_time)) + self.colorizer.write(slow, 'yellow') + self.stream.writeln() + last_cls = None + # sort by name + for elapsed, cls, name in sorted(slow_tests, + key=lambda x: x[1] + x[2]): + if cls != last_cls: + self.colorizer.write(cls, 'white') + self.stream.writeln() + last_cls = cls + self.stream.write(' %s' % str(name).ljust(68)) + self._writeElapsedTime(elapsed) + self.stream.writeln() + + def printErrors(self): + if self.showAll: + self.stream.writeln() + self.printErrorList('ERROR', self.errors) + self.printErrorList('FAIL', self.failures) + + def printErrorList(self, flavor, errors): + for test, err in errors: + self.colorizer.write("=" * 70, 'red') + self.stream.writeln() + self.colorizer.write(flavor, 'red') + self.stream.writeln(": %s" % test.id()) + self.colorizer.write("-" * 70, 'red') + self.stream.writeln() + self.stream.writeln("%s" % err) + + +test = subunit.ProtocolTestCase(sys.stdin, passthrough=None) + +if sys.version_info[0:2] <= (2, 6): + runner = unittest.TextTestRunner(verbosity=2) +else: + runner = unittest.TextTestRunner(verbosity=2, resultclass=ManilaTestResult) + +if runner.run(test).wasSuccessful(): + exit_code = 0 +else: + exit_code = 1 +sys.exit(exit_code) diff --git a/tools/with_venv.sh b/tools/with_venv.sh index c8d2940fc7..94e05c127d 100755 --- a/tools/with_venv.sh +++ b/tools/with_venv.sh @@ -1,4 +1,7 @@ #!/bin/bash -TOOLS=`dirname $0` -VENV=$TOOLS/../.venv -source $VENV/bin/activate && $@ +tools_path=${tools_path:-$(dirname $0)} +venv_path=${venv_path:-${tools_path}} +venv_dir=${venv_name:-/../.venv} +TOOLS=${tools_path} +VENV=${venv:-${venv_path}/${venv_dir}} +source ${VENV}/bin/activate && "$@" diff --git a/tox.ini b/tox.ini index b8508dc942..a751e46d8a 100644 --- a/tox.ini +++ b/tox.ini @@ -1,26 +1,22 @@ [tox] +minversion = 1.6 +skipsdist = True envlist = py26,py27,pep8 [testenv] setenv = VIRTUAL_ENV={envdir} - NOSE_WITH_OPENSTACK=1 - NOSE_OPENSTACK_COLOR=1 - NOSE_OPENSTACK_RED=0.05 - NOSE_OPENSTACK_YELLOW=0.025 - NOSE_OPENSTACK_SHOW_ELAPSED=1 - NOSE_OPENSTACK_STDOUT=1 - LANG=en_US.UTF-8 - LANGUAGE=en_US:en - LC_ALL=C - +usedevelop = True +install_command = pip install {opts} {packages} deps = -r{toxinidir}/requirements.txt -r{toxinidir}/test-requirements.txt -commands = - nosetests {posargs} +commands = python setup.py testr --testr-args='{posargs}' + +[tox:jenkins] +downloadcache = ~/cache/pip [testenv:pep8] commands = - flake8 + flake8 {posargs} . manila/common flake8 --filename=manila* bin [testenv:genconfig] @@ -31,7 +27,10 @@ commands = commands = {posargs} [testenv:cover] -setenv = NOSE_WITH_COVERAGE=1 +setenv = VIRTUAL_ENV={envdir} +commands = + python setup.py testr --coverage \ + --testr-args='^(?!.*test.*coverage).*$' [testenv:pylint] setenv = VIRTUAL_ENV={envdir}