예제 #1
0
    def handle(self, *test_labels, **options):
        """
        Run pylint and test with coverage and xml reports
        """
        patch_for_test_db_setup()

        verbosity = int(options.get('verbosity', 1))
        interactive = options.get('interactive', True)
        excludes = options.get('excludes', '').split(',')
        excludes = [ exclude.strip() for exclude in excludes ]

        tasks = getattr(settings, 'HUDSON_TASKS',
                        ['pylint', 'coverage', 'tests'])

        output_dir=options.get('output_dir')
        if not path.exists(output_dir):
            os.makedirs(output_dir)

        if not test_labels:
            test_labels = Command.test_labels()

        if verbosity > 0:
           print "Testing and covering the following apps:\n %s" % pprint.pformat(test_labels, )

        #TODO: Make lint work and with external rc file
        if 'pylint' in tasks:
            pylint().handle(output_file=path.join(output_dir,'pylint.report'),
                                *test_labels)

        if 'coverage' in tasks:
            coverage.exclude('#pragma[: ]+[nN][oO] [cC][oO][vV][eE][rR]')
            coverage.start()

        failures = 0
        if 'tests' in tasks:
            test_runner = XmlDjangoTestSuiteRunner(output_dir=output_dir, interactive=interactive, verbosity=verbosity)
            failures = test_runner.run_tests(test_labels)

        #save coverage report
        if 'coverage' in tasks:
            coverage.stop()

        modules = [ module for name, module in sys.modules.items() \
                    if hasattr(module, "__file__") and self.want_module(module, test_labels, excludes)
        ]
        morfs = [ self.src(m.__file__) for m in modules if self.src(m.__file__).endswith(".py")]

        if verbosity > 0:
            if excludes:
                print "Excluding any module containing of these words:"
                pprint.pprint(excludes)

            print "Coverage being generated for:"
            pprint.pprint(morfs)

        if 'coverage' in tasks:
            coverage._the_coverage.xml_report(morfs, outfile=path.join(output_dir,'coverage.xml'))

        if failures:
            sys.exit(bool(failures))
예제 #2
0
파일: run.py 프로젝트: Zabrane/ydb-old
def main_coverage(TESTS):
    modulenames = MODULE_NAMES

    coverage.erase()
    coverage.start()
    coverage.exclude('#pragma[: ]+[nN][oO] [cC][oO][vV][eE][rR]')

    modules = []
    for modulename in modulenames:
        print modulenames
        mod = my_import(modulename)
        modules.append(mod)

    if 'unittest' in TESTS:
        print "***** Unittest *****"
        test_args = {'verbosity': 1}
        suite = unittest.TestLoader().loadTestsFromNames(TEST_NAMES)
        unittest.TextTestRunner(**test_args).run(suite)

    if 'doctest' in TESTS:
        t0 = time.time()
        print "\n***** Doctest *****"
        for mod in modules:
            doctest.testmod(mod, verbose=VERBOSE)
        td = time.time() - t0
        print "      Tests took %.3f seconds" % (td, )

    print "\n***** Coverage Python *****"
    coverage.stop()
    coverage.report(modules, ignore_errors=1, show_missing=1)
    coverage.erase()
예제 #3
0
def main_coverage(TESTS):
    modulenames = MODULE_NAMES

    coverage.erase()
    coverage.start()
    coverage.exclude('#pragma[: ]+[nN][oO] [cC][oO][vV][eE][rR]')

    modules = []
    for modulename in modulenames:
        print modulenames
        mod = my_import(modulename)
        modules.append(mod)

    if 'unittest' in TESTS:
        print "***** Unittest *****"
        test_args = {'verbosity': 1}
        suite = unittest.TestLoader().loadTestsFromNames(TEST_NAMES)
        unittest.TextTestRunner(**test_args).run(suite)

    if 'doctest' in TESTS:
        t0 = time.time()
        print "\n***** Doctest *****"
        for mod in modules:
            doctest.testmod(mod, verbose=VERBOSE)
        td = time.time() - t0
        print "      Tests took %.3f seconds" % (td, )

    print "\n***** Coverage Python *****"
    coverage.stop()
    coverage.report(modules, ignore_errors=1, show_missing=1)
    coverage.erase()
예제 #4
0
    def handle(self, *args, **options):
        """
        Run pylint and test with coverage and xml reports
        """
        output_dir=options.get('output_dir')
        if not path.exists(output_dir):
            os.makedirs(output_dir)

        app_labels = Command.app_list()

        # pylint
        pylint().handle(*app_labels, 
                         output_file=path.join(output_dir,'pylint.report'))


        #coverage
        coverage.exclude('#pragma[: ]+[nN][oO] [cC][oO][vV][eE][rR]')
        coverage.start()
        
        #tests
        test_runner = XmlDjangoTestSuiteRunner(output_dir=output_dir)
        failures = test_runner.run_tests(app_labels)

        #save coverage report
        coverage.stop()
        
        modules = [module for name, module in sys.modules.items() \
                       if module and any([name.startswith(label) for label in app_labels])]

        morfs = [ m.__file__ for m in modules if hasattr(m, '__file__') ]
        coverage._the_coverage.xml_report(morfs, outfile=path.join(output_dir,'coverage.xml'))
예제 #5
0
 def begin(self):
     log.debug("Coverage begin")
     import coverage
     self.skipModules = sys.modules.keys()[:]
     if self.coverErase:
         log.debug("Clearing previously collected coverage statistics")
         coverage.erase()
     coverage.exclude('#pragma[: ]+[nN][oO] [cC][oO][vV][eE][rR]')
     coverage.start()
예제 #6
0
def run_tests(test_labels, verbosity=1, interactive=True,
              extra_tests=[]):
    """
    Test runner which displays a code coverage report at the end of the
    run.
    """
    coverage.use_cache(0)
    for e in settings.COVERAGE_CODE_EXCLUDES:
        coverage.exclude(e)
    coverage.start()
    results = base_run_tests(test_labels, verbosity, interactive, extra_tests)
    coverage.stop()

    coverage_modules = []
    if test_labels:
        for label in test_labels:
            label = label.split('.')[0]
            app = get_app(label)
            coverage_modules.append(_get_app_package(app))
    else:
        for app in get_apps():
            coverage_modules.append(_get_app_package(app))

    coverage_modules.extend(settings.COVERAGE_ADDITIONAL_MODULES)

    packages, modules, excludes, errors = get_all_modules(
        coverage_modules, settings.COVERAGE_MODULE_EXCLUDES,
        settings.COVERAGE_PATH_EXCLUDES)

    outdir = settings.COVERAGE_REPORT_HTML_OUTPUT_DIR
    if outdir is None:
        coverage.report(modules.values(), show_missing=1)
        if excludes:
            print >>sys.stdout
            print >>sys.stdout, "The following packages or modules were excluded:",
            for e in excludes:
                print >>sys.stdout, e,
            print >>sys.stdout
        if errors:
            print >>sys.stdout
            print >>sys.stderr, "There were problems with the following packages or modules:",
            for e in errors:
                print >>sys.stderr, e,
            print >>sys.stdout
    else:
        outdir = os.path.abspath(outdir)
        if settings.COVERAGE_CUSTOM_REPORTS:
            html_report(outdir, modules, excludes, errors)
        else:
            coverage._the_coverage.html_report(modules.values(), outdir)
            coverage._the_coverage.xml_report(modules.values(), os.path.join(outdir,'coverage.xml') )
        print >>sys.stdout
        print >>sys.stdout, "HTML reports were output to '%s'" %outdir

    return results
예제 #7
0
    def run_tests(self, test_labels, extra_tests=None, **kwargs):
        coverage.use_cache(settings.COVERAGE_USE_CACHE)
        for e in settings.COVERAGE_CODE_EXCLUDES:
            coverage.exclude(e)
        coverage.start()
        results = super(CoverageRunner, self).run_tests(test_labels,
                                                        extra_tests, **kwargs)
        coverage.stop()

        coverage_modules = []
        if test_labels:
            for label in test_labels:
                label = label.split('.')[0]
                app = get_app(label)
                coverage_modules.append(self._get_app_package(app))
        else:
            for app in get_apps():
                coverage_modules.append(self._get_app_package(app))

        coverage_modules.extend(settings.COVERAGE_ADDITIONAL_MODULES)

        packages, modules, excludes, errors = get_all_modules(
            coverage_modules, settings.COVERAGE_MODULE_EXCLUDES,
            settings.COVERAGE_PATH_EXCLUDES)

        if settings.COVERAGE_USE_STDOUT:
            coverage.report(modules.values(), show_missing=1)
            if excludes:
                message = "The following packages or modules were excluded:"
                print >>sys.stdout
                print >>sys.stdout, message,
                for e in excludes:
                    print >>sys.stdout, e,
                print >>sys.stdout
            if errors:
                message = "There were problems with the following packages "
                message += "or modules:"
                print >>sys.stdout
                print >>sys.stderr, message,
                for e in errors:
                    print >>sys.stderr, e,
                print >>sys.stdout

        outdir = settings.COVERAGE_REPORT_HTML_OUTPUT_DIR
        if outdir:
            outdir = os.path.abspath(outdir)
            if settings.COVERAGE_CUSTOM_REPORTS:
                html_report(outdir, modules, excludes, errors)
            else:
                coverage._the_coverage.html_report(modules.values(), outdir)
            print >>sys.stdout
            print >>sys.stdout, "HTML reports were output to '%s'" %outdir

        return results
예제 #8
0
def run_tests(test_labels, verbosity=1, interactive=True, extra_tests=[]):
    """
    Test runner which displays a code coverage report at the end of the
    run.
    """
    coverage.use_cache(0)
    for e in getattr(settings, 'COVERAGE_CODE_EXCLUDES', []):
        coverage.exclude(e)
    coverage.start()
    results = base_run_tests(test_labels, verbosity, interactive, extra_tests)
    coverage.stop()

    coverage_modules = []
    if test_labels:
        for label in test_labels:
            label = label.split('.')[0]
            app = get_app(label)
            coverage_modules.append(_get_app_package(app))
    else:
        for app in get_apps():
            coverage_modules.append(_get_app_package(app))

    coverage_modules.extend(
        getattr(settings, 'COVERAGE_ADDITIONAL_MODULES', []))

    packages, modules, excludes, errors = get_all_modules(
        coverage_modules, getattr(settings, 'COVERAGE_MODULE_EXCLUDES', []),
        getattr(settings, 'COVERAGE_PATH_EXCLUDES', []))

    coverage.report(modules.values(), show_missing=1)
    if excludes:
        print >> sys.stdout
        print >> sys.stdout, "The following packages or modules were excluded:",
        for e in excludes:
            print >> sys.stdout, e,
        print >> sys.stdout
    if errors:
        print >> sys.stdout
        print >> sys.stderr, "There were problems with the following packages or modules:",
        for e in errors:
            print >> sys.stderr, e,
        print >> sys.stdout

    outdir = getattr(settings, 'COVERAGE_REPORT_HTML_OUTPUT_DIR', 'test_html')
    outdir = os.path.abspath(outdir)
    html_report(outdir, modules, excludes, errors)
    print >> sys.stdout
    print >> sys.stdout, "HTML reports were output to '%s'" % outdir

    return results
예제 #9
0
def begin(self):
    """Used to stub out nose.plugins.cover.Coverage.begin.

  The difference is that it loads Melange after coverage starts, so
  the loading of models, logic and views can be tracked by coverage.
  """
    log.debug("Coverage begin")
    import coverage
    self.skipModules = sys.modules.keys()[:]
    if self.coverErase:
        log.debug("Clearing previously collected coverage statistics")
        coverage.erase()
    coverage.exclude('#pragma[: ]+[nN][oO] [cC][oO][vV][eE][rR]')
    coverage.start()
    load_melange()
예제 #10
0
def begin(self):
  """Used to stub out nose.plugins.cover.Coverage.begin.

  The difference is that it loads Melange after coverage starts, so
  the loading of models, logic and views can be tracked by coverage.
  """
  log.debug("Coverage begin")
  import coverage
  self.skipModules = sys.modules.keys()[:]
  if self.coverErase:
    log.debug("Clearing previously collected coverage statistics")
    coverage.erase()
  coverage.exclude('#pragma[: ]+[nN][oO] [cC][oO][vV][eE][rR]')
  coverage.start()
  load_melange()
예제 #11
0
파일: test.py 프로젝트: PaulRudin/xappy
def make_suite(modnames, other_files, use_coverage, specific_mods):
    topdir = get_topdir()
    # Make a test suite to put all the tests in.
    suite = unittest.TestSuite()

    if use_coverage:
        # Use the coverage test module to get coverage information.
        import coverage
        coverage.erase()
        coverage.start()
        coverage.exclude('#pragma[: ]+[nN][oO] [cC][oO][vV][eE][rR]')

    # Add all the doctest tests.
    modules = []
    for modname in modnames:
        try:
            # Get the path of the module (to search for associated tests)
            modpath = os.path.join(*(modname.split('.')))
            modpath = canonical_path(modpath)
            if os.path.isdir(modpath):
                modpath = os.path.join(modpath, '__init__')

            # Import the module
            sys.path.insert(0, topdir)
            mod = __import__(modname, None, None, [''])
            del sys.path[0]

            # Check that the module imported came from the expected path.
            if os.path.splitext(mod.__file__)[0] != modpath:
                print "Couldn't import module `%s`: got module of same name, from wrong path (%r)" %  (modname, mod.__file__)
                continue

            # Add module to test suite.
            suite.addTest(doctest.DocTestSuite(mod, setUp=setup_test, tearDown=teardown_test))
            modules.append(mod)

            # Check for additional doctest files
            moddir, modfilename = os.path.split(modpath)
            modpath = os.path.join(moddir, "doctests", modfilename + '_doctest%d.txt')
            num = 1
            while os.path.exists(modpath % num):
                suite.addTest(create_docfile_suite(mod, moddir, modpath % num))
                num += 1

        except ImportError, e:
            print "Couldn't import module `%s`: %s" % (modname, e)
            traceback.print_exc()
예제 #12
0
#!/usr/bin/python
""" Test the Cog distribution.
    http://nedbatchelder.com/code/cog

    Copyright 2004-2012, Ned Batchelder.
"""

import unittest, sys

bCoverage = ('-cover' in sys.argv or '--cover' in sys.argv)

if bCoverage:
    import coverage
    coverage.use_cache(0)
    coverage.exclude("#pragma: no cover")
    coverage.exclude("raise CogInternalError\(")
    coverage.start()

testmodules = [
    'cogapp.test_makefiles',
    'cogapp.test_whiteutils',
    'cogapp.test_cogapp',
    ]

# We don't need to import these modules to run the tests.  But loadTestsFromNames
# doesn't show import errors.  These imports do.
exec("import " + ("\nimport ".join(testmodules)))

suite = unittest.TestSuite()

for t in testmodules:
예제 #13
0
import unittest
import coverage
from alexa import alexa_etl, top_list

coverage.exclude('if __name__ == .__main__.:')


class alexaTest(unittest.TestCase):
    def test_etl(self):
        a = alexa_etl()
        first = a.next()

        # first should have a rank of 1 and the second part should be a domain
        self.assertEqual(first[0], 1, \
        "First item in alexa_etl did not have a rank of 1, "
        + "it had a rank of %d"
        % first[0])

        # simple check to see that the first result is a domain
        # i.e. has a dot in it
        self.assertTrue(first[1].count('.') > 0,
                        "alexa_etl did not return a url")

    def test_top_list(self):
        a = top_list(10)
        self.assertEqual(len(a), 10, "top_list did not return 10 items")
        self.assertEqual(a[0][0], 1, "first item was not ranked #1")
        self.assertEqual(
            a[9][0], 10,
            "tenth item was not ranked #10, rank of %d provided" % a[9][0])
예제 #14
0
import unittest
import coverage
from alexa import alexa_etl, top_list

coverage.exclude('if __name__ == .__main__.:')


class alexaTest(unittest.TestCase):

    def test_etl(self):
        a = alexa_etl()
        first = a.next()

        # first should have a rank of 1 and the second part should be a domain
        self.assertEqual(first[0], 1, \
        "First item in alexa_etl did not have a rank of 1, "
        + "it had a rank of %d" 
        % first[0])

        # simple check to see that the first result is a domain
        # i.e. has a dot in it
        self.assertTrue(first[1].count('.') > 0, 
        "alexa_etl did not return a url")

    def test_top_list(self):
        a = top_list(10)
        self.assertEqual(len(a), 10, "top_list did not return 10 items")
        self.assertEqual(a[0][0], 1, "first item was not ranked #1")
        self.assertEqual(a[9][0], 10, 
        "tenth item was not ranked #10, rank of %d provided" % a[9][0])
예제 #15
0
cases and suite within that file or module.  See the sample init and 
testCase files for more information.
"""

import unittest
try:
    import coverage
except ImportError:
    coverage = None
import sys

if coverage:
    coverage.erase()
    coverage.start()

    coverage.exclude('if __name__ == "__main__":')

import dabo.ui

dabo.ui.loadUI('wx')

import db
import biz
import lib
import ui

suiteList = [db.suite(), biz.suite(), lib.suite(), ui.suite()]

#import any tests for the main dabo folder
import Test_dColors
예제 #16
0
        try:
            cursor.execute(data)
            transaction.commit_unless_managed()
        except Exception,err:
            print 'DB Schema load error: ',err
        else:
            print 'DB Schema loaded.'
    else:
        print 'No Schema found.'
    
    print 'Start running tests.'
    #####

    coverage.use_cache(0)
    for e in default_settings.COVERAGE_CODE_EXCLUDES:
        coverage.exclude(e)
    coverage.start()

    #####

    nose.run(argv=nose_argv)

    #####

    coverage.stop()
    #####
    
    print 'Testing ended.'

    # Clean up django.
    connection.creation.destroy_test_db(old_db_name, verbosity)
예제 #17
0
# Coverage-test coverage.py!

import coverage
import test_coverage
import unittest
import sys

print "Testing under Python version:\n", sys.version

coverage.erase()
coverage.start()
coverage.exclude("#pragma: no cover")

# Re-import coverage to get it coverage tested!
covmod = sys.modules['coverage']
del sys.modules['coverage']
import coverage
sys.modules['coverage'] = coverage = covmod

suite = unittest.TestSuite()
suite.addTest(unittest.defaultTestLoader.loadTestsFromNames(["test_coverage"]))

testrunner = unittest.TextTestRunner()
testrunner.run(suite)

coverage.stop()
coverage.report("coverage.py")
예제 #18
0
cases and suite within that file or module.  See the sample init and 
testCase files for more information.
"""

import unittest
try:
	import coverage
except ImportError:
	coverage = None
import sys

if coverage:
	coverage.erase()
	coverage.start()

	coverage.exclude('if __name__ == "__main__":')

import dabo.ui
dabo.ui.loadUI('wx')

import db
import biz
import lib
import ui

suiteList = [db.suite(), biz.suite(), lib.suite(), ui.suite()]

#import any tests for the main dabo folder
import Test_dColors
suiteList.append(unittest.TestLoader().loadTestsFromModule(Test_dColors))
import Test_dObject
예제 #19
0
    def handle(self, *test_labels, **options):
        """
        Run pylint and test with coverage and xml reports
        """
        patch_for_test_db_setup()

        verbosity = int(options.get('verbosity', 1))
        interactive = options.get('interactive', True)
        excludes = options.get('excludes', '').split(',')
        excludes = [exclude.strip() for exclude in excludes]

        tasks = getattr(settings, 'HUDSON_TASKS',
                        ['pylint', 'coverage', 'tests'])

        output_dir = options.get('output_dir')
        if not path.exists(output_dir):
            os.makedirs(output_dir)

        if not test_labels:
            test_labels = Command.test_labels()

        if verbosity > 0:
            print "Testing and covering the following apps:\n %s" % pprint.pformat(
                test_labels, )

        #TODO: Make lint work and with external rc file
        if 'pylint' in tasks:
            pylint().handle(output_file=path.join(output_dir, 'pylint.report'),
                            *test_labels)

        if 'coverage' in tasks:
            coverage.exclude('#pragma[: ]+[nN][oO] [cC][oO][vV][eE][rR]')
            coverage.start()

        failures = 0
        if 'tests' in tasks:
            test_runner = XmlDjangoTestSuiteRunner(output_dir=output_dir,
                                                   interactive=interactive,
                                                   verbosity=verbosity)
            failures = test_runner.run_tests(test_labels)

        #save coverage report
        if 'coverage' in tasks:
            coverage.stop()

        modules = [ module for name, module in sys.modules.items() \
                    if hasattr(module, "__file__") and self.want_module(module, test_labels, excludes)
        ]
        morfs = [
            self.src(m.__file__) for m in modules
            if self.src(m.__file__).endswith(".py")
        ]

        if verbosity > 0:
            if excludes:
                print "Excluding any module containing of these words:"
                pprint.pprint(excludes)

            print "Coverage being generated for:"
            pprint.pprint(morfs)

        if 'coverage' in tasks:
            coverage._the_coverage.xml_report(morfs,
                                              outfile=path.join(
                                                  output_dir, 'coverage.xml'))

        if failures:
            sys.exit(bool(failures))
예제 #20
0
파일: cui.py 프로젝트: dhellmann/proctor
    def main(self, *args):

        #
        # Strip arguments from the command line, so our
        # args do not confuse another app or library.
        #
        sys.argv = [ sys.argv[0] ]

        #
        # If they asked for a list of the tests, print that
        # first.
        #
        if self.list_mode:
            module_tree = self.getModuleTree(args)
            success = self.listTests(module_tree)

        #
        # If they asked for a list of test categories,
        # print that here.
        #
        elif self.list_categories_mode:
            module_tree = self.getModuleTree(args)
            success = self.listCategories(module_tree)

        #
        # If they asked to have tests run, do that
        # last.
        #
        elif self.run_mode:
                
            if coverage and self.code_coverage:
                #
                # Possibly override the coverage filename
                #
                if self.coverage_filename:
                    self.statusMessage('Writing coverage output to %s' % self.coverage_filename)
                    import os
                    os.environ['COVERAGE_FILE'] = self.coverage_filename

                #
                # Clean up in case we have previous coverage data
                #
                coverage.erase()
                #
                # Add exclude patterns
                #
                for pattern in self.coverage_exclude_patterns:
                    coverage.exclude(pattern)
                #
                # Start code coverage counter
                #
                coverage.start()
                
            #
            # Get the module tree.  This needs to be done *after*
            # coverage monitoring is started so we monitor those
            # modules, too.
            #
            module_tree = self.getModuleTree(args)
            
            #
            # Run the tests
            #
            result = self.runTests(module_tree)

            if coverage and self.code_coverage:
                #
                # Stop coverage counter and save its results
                #
                coverage.stop()
                coverage.the_coverage.save()
                
            #
            # Report our success/failure
            #
            success = result.wasSuccessful()

        return success
예제 #21
0
    def run_tests(self, test_labels, extra_tests=None, **kwargs):
        coverage.use_cache(settings.COVERAGE_USE_CACHE)
        for e in settings.COVERAGE_CODE_EXCLUDES:
            coverage.exclude(e)
        coverage.start()
        results = super(CoverageRunner, self).run_tests(test_labels,
                                                        extra_tests, **kwargs)
        coverage.stop()

        coverage_modules = []
        if test_labels:
            for label in test_labels:
                label = label.split('.')[0]
                app = get_app(label)
                coverage_modules.append(self._get_app_package(app))
        else:
            for app in get_apps():
                coverage_modules.append(self._get_app_package(app))

        coverage_modules.extend(settings.COVERAGE_ADDITIONAL_MODULES)

        packages, modules, excludes, errors = get_all_modules(
            coverage_modules, settings.COVERAGE_MODULE_EXCLUDES,
            settings.COVERAGE_PATH_EXCLUDES)

        if settings.COVERAGE_USE_STDOUT:
            coverage.report(list(modules.values()), show_missing=1)
            if excludes:
                message = "The following packages or modules were excluded:"
                print("")
                print(message)
                for e in excludes:
                    print(e)
                print("")
            if errors:
                message = "There were problems with the following packages "
                message += "or modules:"
                print("")
                print(message)
                for e in errors:
                    print(e)
                print("")

        outdir = settings.COVERAGE_REPORT_HTML_OUTPUT_DIR
        if outdir:
            outdir = os.path.abspath(outdir)
            if settings.COVERAGE_CUSTOM_REPORTS:
                html_report(outdir, modules, excludes, errors)
            else:
                coverage._the_coverage.html_report(list(modules.values()), outdir)
            print("")
            print("HTML reports were output to '%s'" %outdir)

        datafile = settings.COVERAGE_REPORT_DATA_FILE
        if datafile:
            covered_files = coverage._the_coverage.data.lines.keys()
            covered_arcs = coverage._the_coverage.data.arcs.keys()
            modfiles = []
            for module in modules.values():
                modfiles.append(module.__file__.replace('.pyc', '.py'))
            for filename in covered_files:
                if not filename in modfiles and filename in coverage._the_coverage.data.lines:
                    del coverage._the_coverage.data.lines[filename]
            for filename in covered_arcs:
                if not filename in modfiles and filename in coverage._the_coverage.data.arcs:
                    del coverage._the_coverage.data.arcs[filename]
            coverage._the_coverage.data.usefile(True)
            coverage._the_coverage.data.write_file(datafile)

        return results
예제 #22
0
#!/usr/bin/env python
"""
    Inyoka Testrunner
    ~~~~~~~~~~~~~~~~~

    Note, that running the tests is not available via manage-inyoka.py, cause
    we import some stuff there and that does kill coverage.

    :copyright: 2009-2011 by the Inyoka Team, see AUTHORS for more details.
    :license: GNU GPL, see LICENSE for more details.
"""
import nose, os, sys

import coverage
coverage.erase()
coverage.exclude('#pragma[: ]+[nN][oO] [cC][oO][vV][eE][rR]')
coverage.exclude('__repr__.*')
coverage.coverage(auto_data=True, branch=True)
coverage.start()

# set the configuration file
if 'INYOKA_CONFIG' not in os.environ:
    os.environ['INYOKA_CONFIG'] = 'inyoka_tests.ini'
from inyoka.core.test import InyokaPlugin, FuturePlugin
from inyoka.core.database import refresh_engine


def run_suite(module='inyoka'):
    # We need debug set to True for our tests
    from inyoka.context import ctx
    ctx.cfg['debug'] = 0
예제 #23
0
        self.delivery_tag = None




if __name__ == '__main__':
    import sys
    import doctest
    try:
        import coverage
    except ImportError:
        print >> sys.stderr, " [*] python-coverage not found"
        coverage = None

    if coverage:
        coverage.erase()
        coverage.start()
        coverage.exclude('#pragma[: ]+[nN][oO] [cC][oO][vV][eE][rR]')


    import amqpqueue
    modules = [amqpqueue]
    for module in modules:
        doctest.testmod(module)

    if coverage:
        coverage.stop()
        coverage.report(modules, ignore_errors=1, show_missing=1)
        coverage.erase()

예제 #24
0
def run_tests(test_labels, verbosity=1, interactive=True,
              extra_tests=[]):
    """
    Test runner which displays a code coverage report at the end of the
    run.
    """
    ##############################
    setup_funcs, teardown_funcs = get_test_enviroment_functions()
    # Prepare django for testing.
    setup_test_environment(setup_funcs)
    old_db_name = settings.DATABASE_NAME
    connection.creation.create_test_db(verbosity, autoclobber=not interactive)

    # Pretend it's a production environment.
    settings.DEBUG = False

    nose_argv = ['nosetests']
    if hasattr(settings, 'NOSE_ARGS'):
        nose_argv.extend(settings.NOSE_ARGS)

    # Everything after '--' is passed to nose.
    if '--' in sys.argv:
        hyphen_pos = sys.argv.index('--')
        nose_argv.extend(sys.argv[hyphen_pos + 1:])

    if verbosity >= 1:
        print ' '.join(nose_argv)

    ############################

    coverage.use_cache(0)
    for e in settings.COVERAGE_CODE_EXCLUDES:
        coverage.exclude(e)
    coverage.start()
    nose.run(argv=nose_argv)    
    #results = base_run_tests(test_labels, verbosity, interactive, extra_tests)
    coverage.stop()

    coverage_modules = []
    if test_labels:
        for label in test_labels:
            label = label.split('.')[0]
            app = get_app(label)
            coverage_modules.append(_get_app_package(app))
    else:
        for app in get_apps():
            coverage_modules.append(_get_app_package(app))

    coverage_modules.extend(settings.COVERAGE_ADDITIONAL_MODULES)

    packages, modules, excludes, errors = get_all_modules(
        coverage_modules, settings.COVERAGE_MODULE_EXCLUDES,
        settings.COVERAGE_PATH_EXCLUDES)

    outdir = settings.COVERAGE_REPORT_HTML_OUTPUT_DIR
    if outdir is None:
        coverage.report(modules.values(), show_missing=1)
        if excludes:
            print >>sys.stdout
            print >>sys.stdout, "The following packages or modules were excluded:",
            for e in excludes:
                print >>sys.stdout, e,
            print >>sys.stdout
        if errors:
            print >>sys.stdout
            print >>sys.stderr, "There were problems with the following packages or modules:",
            for e in errors:
                print >>sys.stderr, e,
            print >>sys.stdout
    else:
        outdir = os.path.abspath(outdir)
        if settings.COVERAGE_CUSTOM_REPORTS:
            html_report(outdir, modules, excludes, errors)
        else:
            coverage._the_coverage.html_report(modules.values(), outdir)
        print >>sys.stdout
        print >>sys.stdout, "HTML reports were output to '%s'" %outdir

    ###########################
    # Clean up django.
    connection.creation.destroy_test_db(old_db_name, verbosity)
    teardown_test_environment(teardown_funcs)
    ###########################

    return results