예제 #1
0
파일: test.py 프로젝트: PaulRudin/xappy
def run_tests(modnames, other_files, use_coverage, specific_mods):
    """Run tests on the specified modules.

    Returns a list of modules which were tested.

    """

    # Check command line for overrides to module names
    if specific_mods:
        newnames = []
        for arg in specific_mods:
            if arg in modnames:
                newnames.append(arg)
            else:
                print "Module `%s' not known" % arg
                sys.exit(1)
        modnames = newnames

    modules, suite = make_suite(modnames, other_files, use_coverage, specific_mods)

    # Now, run everything.
    runner = unittest.TextTestRunner()
    runner.run(suite)

    if use_coverage:
        # Finished run - stop the coverage tests
        import coverage
        coverage.stop()
    return modules
예제 #2
0
파일: __init__.py 프로젝트: lhm-limux/gosa
def stop(stream, packages, target, collect=False):
    """Stop coverage"""
    # Call stop
    coverage.stop()
    # Collect if asked
    if collect:
        coverage.the_coverage.collect()
    # Get the file descriptor for the report
    fd = StringIO.StringIO()
    # Get the report
    coverage.report(packages, file=fd)
    # Flush
    fd.flush()
    # Write on stream
    stream.write(fd.getvalue())
    # Write in target
    ntools.save(fd.getvalue(), os.path.join(target, "coverage.dat"), binary=False)
    # Get the sources
    sources = parse(fd.getvalue())
    # Close the file descriptor
    fd.close()
    # Annotate source files
    annotate(packages, target, ignore_errors=True)
    # Create report
    report(target, sources)
예제 #3
0
def main():
    from optparse import OptionParser
    usage = ('Usage: %prog [option] [modules to be tested]\n'
             'Modules names have to be given in the form utils.mail (without '
             'zine.)\nIf no module names are given, all tests are run')
    parser = OptionParser(usage=usage)
    parser.add_option('-c', '--coverage', action='store_true', dest='coverage',
                      help='show coverage information (slow!)')
    parser.add_option('-v', '--verbose', action='store_true', dest='verbose',
                      default=False, help='show which tests are run')

    options, args = parser.parse_args(sys.argv[1:])
    modnames = ['zine.' + modname for modname in args]
    if options.coverage:
        if coverage is not None:
            use_coverage = True
        else:
            sys.stderr.write("coverage information requires Ned Batchelder's "
                             "coverage.py to be installed!\n")
            sys.exit(1)
    else:
        use_coverage = False

    if use_coverage:
        coverage.erase()
        coverage.start()
        s, covermods = suite(modnames, True)
    else:
        s = suite(modnames)
    TextTestRunner(verbosity=options.verbose + 1).run(s)
    if use_coverage:
        coverage.stop()
        print '\n\n' + '=' * 25 + ' coverage information ' + '=' * 25
        coverage.report(covermods)
예제 #4
0
    def run_tests(self, test_labels, verbosity=1, interactive=True, extra_tests=[]):
        coveragemodules = getattr(settings, 'COVERAGE_MODULES', [])

        if coveragemodules:
            coverage.start()

        self.setup_test_environment()

        suite = self.build_suite(test_labels, extra_tests)
        old_config = self.setup_databases()
        result = self.run_suite(suite)

        if coveragemodules:
            coverage.stop()
            coveragedir = getattr(settings, 'COVERAGE_DIR', './build/coverage')
            if not os.path.exists(coveragedir):
                os.makedirs(coveragedir)

            modules = []
            for module_string in coveragemodules:
                module = __import__(module_string, globals(), locals(), [""])
                modules.append(module)
                f,s,m,mf = coverage.analysis(module)
                fp = file(os.path.join(coveragedir, module_string + ".html"), "wb")
                colorize.colorize_file(f, outstream=fp, not_covered=mf)
                fp.close()
            coverage.report(modules, show_missing=0)
            coverage.erase()

        self.teardown_databases(old_config)
        self.teardown_test_environment()

        return len(result.failures) + len(result.errors)
예제 #5
0
    def run(self):
        testfiles = []
        testdirs = ["koan"]

        for d in testdirs:
            testdir = os.path.join(os.getcwd(), "tests", d)

            for t in _glob.glob(os.path.join(testdir, '*.py')):
                if t.endswith('__init__.py'):
                    continue
                testfile = '.'.join(['tests', d,
                                     os.path.splitext(os.path.basename(t))[0]])
                testfiles.append(testfile)

        tests = unittest.TestLoader().loadTestsFromNames(testfiles)
        runner = unittest.TextTestRunner(verbosity=1)

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

        result = runner.run(tests)

        if coverage:
            coverage.stop()
        sys.exit(int(bool(len(result.failures) > 0 or
                          len(result.errors) > 0)))
예제 #6
0
def report_coverage(packages):
    test_re = re.compile('.+test[^%s.]*\..+' % os.sep)
    coverage.stop()
    files = set()
    for name in sys.modules:
        mod = sys.modules.get(name)
        if mod is None:
            continue
        elif not is_in_packages(name, packages):
            continue
        elif is_in_packages(name, ['django']):
            continue

        filename = mod.__file__.replace('.pyc', '.py')

        if test_re.match(filename):
            continue

        st = os.stat(filename)
        if st.st_size > 1:
            files.add(filename)

    if files:
        coverage.report(list(files))
    coverage.erase()
예제 #7
0
    def _run_with_coverage(self):
        import coverage
        coverage.use_cache(False)
        coverage.start()
        try:
            self._run_tests()
        finally:
            coverage.stop()

            modules = [m for _, m in sys.modules.items()
                       if m is not None and hasattr(m, '__file__')
                       and os.path.splitext(m.__file__)[-1] in ('.py', '.pyc')]

            # Generate summary file
            buf = StringIO()
            coverage.report(modules, file=buf)
            buf.seek(0)
            fileobj = open(self.coverage_summary, 'w')
            try:
                filter_coverage(buf, fileobj)
            finally:
                fileobj.close()

            if self.coverage_dir:
                if not os.path.exists(self.coverage_dir):
                    os.makedirs(self.coverage_dir)
                coverage.annotate(modules, directory=self.coverage_dir,
                                  ignore_errors=True)
예제 #8
0
    def doctest(self):
        import doctest, coverage
        # (f,t) = doctest.testmod(eval('isconf.Kernel'))
        # doctest.master.summarize()
        # sys.exit(f)

        modules = []
        olddir = os.getcwd()
        os.chdir('lib/python')
        os.path.walk('.',getmods,modules)
        os.chdir(olddir)
        print modules
        
        # modules=[rpc822]

        fail=0
        total=0
        coverage.erase()
        coverage.start()
        for mod in modules:
            (f,t) = doctest.testmod(mod,report=0)
            fail += f
            total += t
        doctest.master.summarize()
        coverage.stop()
        for mod in modules:
            coverage.analysis(mod)
        coverage.report(modules)
        sys.exit(fail)
예제 #9
0
def run_tests(*args, **kwargs):
  """Custom test runner.  Follows the django.test.simple.run_tests()
  interface."""
  coverage.use_cache(0) # Do not cache any of the coverage.py stuff
  coverage.start()
 
  test_results = django_test_runner(*args, **kwargs)
 
  # Stop code coverage after tests have completed
  coverage.stop()
 
  # Print code metrics header
  print ''
  print '----------------------------------------------------------------------'
  print ' Unit Test Code Coverage Results'
  print '----------------------------------------------------------------------'
 
  # Report code coverage metrics
  coverage_modules = []
  for module in settings.COVERAGE_MODULES:
      coverage_modules.append(__import__(module, globals(), locals(), ['']))
 
  coverage.report(coverage_modules, show_missing=1)
 
  # Print code metrics footer
  print '----------------------------------------------------------------------'
  return test_results
예제 #10
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))
예제 #11
0
def test_runner_with_coverage(test_labels, verbosity=1, interactive=True,
                              extra_tests=[]):
    # This doesn't work with Django 1.4
    from django.test.simple import run_tests as django_test_runner
    import coverage

    coverage.use_cache(0)
    coverage.start()

    test_results = django_test_runner(test_labels, verbosity, interactive,
                                      extra_tests)

    coverage.stop()
    coverage_modules = [m.__file__ for k, m in sys.modules.iteritems()
                        if m and k.split('.')[0] in test_labels
                        and 'test' not in k]
    print
    print '='*80
    print 'Coverage results for %s' % ', '.join(test_labels)
    print '='*80
    coverage.report(coverage_modules, show_missing=1)
    coverage_html_dir = getattr(settings, 'COVERAGE_HTML_DIR', None)
    if coverage_html_dir is not None:
        coverage._the_coverage.html_report(coverage_modules,
                                           coverage_html_dir)

    return test_results
예제 #12
0
def test_runner_with_coverage(test_labels, verbosity=1, interactive=True, extra_tests=[]):
    """Custom test runner.  Follows the django.test.simple.run_tests() interface."""
    # Start code coverage before anything else if necessary
    coverage_modules = []
    for module_name in settings.COVERAGE_MODULES:
        app_name = module_name.split(".")[0]
        if (not test_labels) or (app_name in test_labels):
            coverage_modules.append(__import__(module_name, globals(), locals(), ['']))
 
    if hasattr(settings, 'COVERAGE_MODULES'):
        coverage.use_cache(0) # Do not cache any of the coverage.py stuff
        coverage.start()
 
    test_results = django_test_runner(test_labels, verbosity, interactive, extra_tests)
 
    # Stop code coverage after tests have completed
    if hasattr(settings, 'COVERAGE_MODULES'):
        coverage.stop()
 
        # Print code metrics header
        print ''
        print '----------------------------------------------------------------------'
        print ' Unit Test Code Coverage Results'
        print '----------------------------------------------------------------------'
 
        coverage.report(coverage_modules, show_missing=1)
 
        # Print code metrics footer
        print '----------------------------------------------------------------------'
    else:
        print "No coverage modules defined in settings.py"
 
    return test_results
예제 #13
0
파일: runners.py 프로젝트: rob-b/Grab
def test_runner_with_coverage(test_labels, verbosity=1, interactive=True, extra_tests=[]):
    """Custom test runner.  Follows the django.test.simple.run_tests() interface."""
    coverage.use_cache(0) # Do not cache any of the coverage.py stuff
    coverage.start()
    test_results = django_test_runner(test_labels, verbosity, interactive, extra_tests)
    coverage.stop()

    coverage_modules = []
    if test_labels:
        for label in test_labels:
            # Don't report coverage if you're only running a single
            # test case.
            if '.' not in label:
                app = get_app(label)
                coverage_modules.extend(get_coverage_modules(app))
    else:
        for app in get_apps():
            coverage_modules.extend(get_coverage_modules(app))


    if coverage_modules:
        # Print code metrics header
        print ''
        print '----------------------------------------------------------------------'
        print ' Unit Test Code Coverage Results'
        print '----------------------------------------------------------------------'
        coverage.report(coverage_modules, show_missing=1)
        # Print code metrics footer
        print '----------------------------------------------------------------------'
    return test_results
예제 #14
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()
예제 #15
0
    def run(self):
        try:
            # Use system 'coverage' if available
            import coverage
            use_coverage = True
        except:
            use_coverage = False

        tests = unittest.TestLoader().loadTestsFromNames(self._testfiles)
        t = unittest.TextTestRunner(verbosity=1)

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

        if hasattr(unittest, "installHandler"):
            try:
                unittest.installHandler()
            except:
                print "installHandler hack failed"

        try:
            result = t.run(tests)
        except KeyboardInterrupt:
            sys.exit(1)

        if use_coverage:
            coverage.stop()

        sys.exit(int(bool(len(result.failures) > 0 or
                          len(result.errors) > 0)))
예제 #16
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.
    """
    django_test_runner = get_runner(settings)
    coverage.use_cache(0)
    coverage.start()
    
    results = django_test_runner(test_labels, verbosity, interactive, 
        extra_tests)
    coverage.stop()

    coverage_modules = []
    if test_labels:
        for label in test_labels:
            # Don't report coverage if you're only running a single
            # test case.
            if '.' not in label:
                app = get_app(label)
                coverage_modules.extend(get_all_coverage_modules(app))
    else:
        for app in get_apps():
            coverage_modules.extend(get_all_coverage_modules(app))

    if coverage_modules:
        coverage.report(coverage_modules, show_missing=1)

    return results
예제 #17
0
def test_runner_with_coverage(test_labels, verbosity=1, interactive=True,
                              extra_tests=[]):
    """Custom test runner.  Follows the django.test.simple.run_tests()
    interface."""

    do_coverage = hasattr(settings, 'COVERAGE_MODULES') and settings.COVERAGE_MODULES
    # Start code coverage before anything else if necessary
    if do_coverage:
        coverage.use_cache(0) # Do not cache any of the coverage.py stuff
        coverage.start()
 
    test_results = django_test_runner(test_labels, verbosity, interactive, extra_tests)
 

    if do_coverage:
        coverage.stop()
        # Print code metrics header
        print
        print '-' * 60
        print ' Unit Test Code Coverage Results'
        print '-' * 60
 
        coverage_modules = []
        for module in settings.COVERAGE_MODULES:
            coverage_modules.append(__import__(module, globals(), locals(),
                                               ['']))
 
        coverage.report(coverage_modules, show_missing=1)
 
        # Print code metrics footer
        print '-' * 60
 
    return test_results
예제 #18
0
파일: tester.py 프로젝트: ReedSIN/webapps
    def report():
        if run:
            run()
        if success.count and not failure.count:
            print("ok")
            # only clean out tempfiles if test passed
            import os, os.path, tempfile
            for file in _tempfiles:
                try:
                    os.remove(file)
                except OSError:
                    pass # report?
            temp_root = os.path.join(tempfile.gettempdir(), 'pillow-tests')
            try:
                os.rmdir(temp_root)
            except OSError:
                pass

        if "--coverage" in sys.argv:
            import coverage
            coverage.stop()
            # The coverage module messes up when used from inside an
            # atexit handler.  Do an explicit save to make sure that
            # we actually flush the coverage cache.
            coverage.the_coverage.save()
예제 #19
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'))
예제 #20
0
파일: test.py 프로젝트: jsquyres/mtt
def run_tests(verbosity):
    "Run test suite"

    # list all the files in the top level directory
    file_list = os.listdir(os.path.join(os.path.abspath(
        os.path.dirname(os.path.realpath(__file__)))))

    # list all the files in the tests directory
    test_list = os.listdir(os.path.join(os.path.abspath(
        os.path.dirname(os.path.realpath(__file__))), 'tests'))

    code_modules = []
    # loop over all the file names
    for file_name in file_list:
        extension = os.path.splitext(file_name)[-1]
        # if they are python files or the test runner
        if extension == '.py' and file_name != 'test.py':
            # work out the module name
            code_module_name = os.path.splitext(file_name)[0:-1][0]
            # now import the module
            module = __import__(code_module_name, globals(), locals(), 
                code_module_name)
            # and add it to the list of available modules
            code_modules.append(module)

    test_modules = []
    # loop over all the file names
    for file_name in test_list:
        extension = os.path.splitext(file_name)[-1]
        # if they are python files
        if extension == '.py':
            # work out the module name
            test_module_name = "tests." + os.path.splitext(file_name)[0:-1][0]
            # now import the module
            module = __import__(test_module_name, globals(), locals(), 
                test_module_name)
            # and add it to the list of available modules
            test_modules.append(module)
        
    # populate a test suite from the individual tests from the list of modules
    suite = unittest.TestSuite(map(
        unittest.defaultTestLoader.loadTestsFromModule, test_modules))

    # set up the test runner
    runner = unittest.TextTestRunner(verbosity=int(verbosity))
    
    # set up coverage reporting
    coverage.use_cache(0)
    coverage.start()
    
    # run the tests
    runner.run(suite)
    
    # stop coverage reporting
    coverage.stop()
    
    # output coverage report
    coverage.report(code_modules, show_missing=1)
예제 #21
0
 def report(self, stream):
     log.debug("Coverage report")
     import coverage
     coverage.stop()
     modules = [ module
                 for name, module in sys.modules.items()
                 if self.wantModuleCoverage(name, module) ]
     log.debug("Coverage report will cover modules: %s", modules)
     coverage.report(modules, file=stream)
예제 #22
0
 def report_coverage():
     coverage.stop()
     module_list = [
         mod for name, mod in sys.modules.copy().iteritems() if
         getattr(mod, '__file__', None) and
         name.startswith('jinja2.') and
         name not in IGNORED_MODULES
     ]
     module_list.sort()
     coverage.report(module_list)
예제 #23
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
예제 #24
0
파일: runner.py 프로젝트: pioneer/42cc-test
def run_tests(test_labels, verbosity=1, interactive=True, extra_tests=[]):
    """
    Run the unit tests for all the test labels in the provided list.
    Labels must be of the form:
     - app.TestClass.test_method
        Run a single specific test method
     - app.TestClass
        Run all the test methods in a given class
     - app
        Search for doctests and unittests in the named application.

    When looking for tests, the test runner will look in the models and
    tests modules for the application.

    A list of 'extra' tests may also be provided; these tests
    will be added to the test suite.

    If the settings file has an entry for COVERAGE_MODULES or test_labels is true it will prints the
    coverage report for modules/apps

    Returns number of tests that failed.
    """
    
    do_coverage = hasattr(settings, 'COVERAGE_MODULES') or bool(test_labels)
    if do_coverage:
        coverage.erase()
        coverage.start()

    from django.test import simple
    retval = simple.run_tests(test_labels, verbosity, interactive, extra_tests)

    if do_coverage:
        coverage.stop()

        # Print code metrics header
        print ''
        print '----------------------------------------------------------------------'
        print ' Unit Test Code Coverage Results'
        print '----------------------------------------------------------------------'

	# try to import all modules for the coverage report.
        modules = []
        if getattr(settings, 'COVERAGE_MODULES', None):
            modules = [__import__(module, {}, {}, ['']) for module in settings.COVERAGE_MODULES]

        elif test_labels:
            modules = []
            for label in test_labels:
                label = label.split('.')[0] #remove test class or test method from label
                pkg = _get_app_package(label)
                modules.extend(_package_modules(*pkg))

        coverage.report(modules, show_missing=1)

    return retval
예제 #25
0
def main():
    import unittest
    from getopt import getopt, GetoptError

    try:
        options, arguments = getopt(sys.argv[1:], "d:v",
            ["database=", "extra-verbose", "super-verbose",
            "inserts", "coverage"])
    except GetoptError:
        sys.exit("Usage: %s [-d|--database all|type] [-v[v]] [--extra-verbose|--super-verbose] [--inserts] [--coverage]" % sys.argv[0])

    dbs = []
    newArgs = []
    doCoverage = False
    verbose = 0

    for option, value in options:
        if option in ('-d', '--database'):
            dbs.append(value)
        elif option == '--inserts':
            SQLObjectTest.debugInserts = True
        elif option == '--coverage':
            # Handled earlier, so we get better coverage
            doCoverage = True
        elif option == '--extra-verbose':
            verbose = 1
        elif option == '--super-verbose':
            verbose = 2
        elif option == '-v':
            verbose += 1

    if verbose >= 1:
        SQLObjectTest.debugSQL = True
    if verbose >= 2:
        SQLObjectTest.debugOutput = True
        newArgs.append('-vv')
    newArgs.extend(arguments)

    sys.argv = [sys.argv[0]] + newArgs
    if not dbs:
        dbs = ['mysql']
    if dbs == ['all']:
        dbs = supportedDatabases()
    for db in dbs:
        print 'Testing %s' % db
        curr_db = db
        setDatabaseType(db)
        try:
            unittest.main()
        except SystemExit:
            pass
    if doCoverage:
        coverage.stop()
        coverModules()
예제 #26
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
예제 #27
0
 def report(self, stream):
     """
     Output code coverage report.
     """
     import coverage
     coverage.stop()
     modules = [ module
                 for name, module in sys.modules.items()
                 if self.wantModuleCoverage(name, module) ]
     log.debug("Coverage report will cover modules: %s", modules)
     morfs = [ m.__file__ for m in modules if hasattr(m, '__file__') ]
     coverage._the_coverage.xml_report(morfs, outfile=self.xcoverageFile)
예제 #28
0
def nose_start(LOG, REPO_PATH):  # test names
    """
    Find all python modules in REPO_PATH
    """
    WORKING_DIR = getcwd()
    chdir(REPO_PATH)
    coverage.erase()
    coverage.start()
    nose.run()
    coverage.stop()
    LOG.info(coverage.analysis(nose))
    LOG.info(coverage.report())
    chdir(WORKING_DIR)
예제 #29
0
파일: funccover.py 프로젝트: Lorquas/func
 def report(self, stream):
     log.debug("Coverage report")
     import coverage
     coverage.stop()
     modules = [ module
                 for name, module in sys.modules.items()
                 if self.wantModuleCoverage(name, module) ]
     log.debug("Coverage report will cover modules: %s", modules)
     if self.coverDir and self.coverAnnotate:
         coverage.annotate(modules, self.coverDir)
     fd = open("%s/cover.report" % self.coverDir, "w")
     coverage.report(modules, file=fd)
     fd.close()
예제 #30
0
 def runTests(self):       
     testrunner = TextTestRunnerWithTimings(
         verbosity=self._options.verbosity,
         timeTests=self._options.time,
         nrTestsToReport=self._options.time_reports)
     if self._options.coverage:
         coverage.erase()
         coverage.start()
     result = testrunner.run(self)
     if self._options.coverage:
         coverage.stop()
         print coverage.report(self.getPyFilesFromDir(os.path.join(projectRoot, 
             'taskcoachlib')))
     return result
예제 #31
0
def run_tests(verbosity):
    "Run test suite"

    # list all the files in the top level directory
    file_list = os.listdir(
        os.path.join(
            os.path.abspath(os.path.dirname(os.path.realpath(__file__)))))

    # list all the files in the tests directory
    test_list = os.listdir(
        os.path.join(
            os.path.abspath(os.path.dirname(os.path.realpath(__file__))),
            'tests'))

    code_modules = []
    # loop over all the file names
    for file_name in file_list:
        extension = os.path.splitext(file_name)[-1]
        # if they are python files or the test runner
        if extension == '.py' and file_name != 'test.py':
            # work out the module name
            code_module_name = os.path.splitext(file_name)[0:-1][0]
            # now import the module
            module = __import__(code_module_name, globals(), locals(),
                                code_module_name)
            # and add it to the list of available modules
            code_modules.append(module)

    test_modules = []
    # loop over all the file names
    for file_name in test_list:
        extension = os.path.splitext(file_name)[-1]
        # if they are python files
        if extension == '.py':
            # work out the module name
            test_module_name = "tests." + os.path.splitext(file_name)[0:-1][0]
            # now import the module
            module = __import__(test_module_name, globals(), locals(),
                                test_module_name)
            # and add it to the list of available modules
            test_modules.append(module)

    # populate a test suite from the individual tests from the list of modules
    suite = unittest.TestSuite(
        map(unittest.defaultTestLoader.loadTestsFromModule, test_modules))

    # set up the test runner
    runner = unittest.TextTestRunner(verbosity=int(verbosity))

    # set up coverage reporting
    coverage.use_cache(0)
    coverage.start()

    # run the tests
    runner.run(suite)

    # stop coverage reporting
    coverage.stop()

    # output coverage report
    coverage.report(code_modules, show_missing=1)
예제 #32
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))
예제 #33
0
    print >> sys.stderr, '=' * WIDTH
    if failed:
        print >>sys.stderr, '%d of %d tests failed.' % \
              (error_test_count, total_test_count)
        print >> sys.stderr, 'Tests failed in:', ', '.join(failed)
        ret = 1
    else:
        if total_test_count == 1:
            print >> sys.stderr, '1 test happy.'
        else:
            print >> sys.stderr, 'All %d tests happy.' % total_test_count
        ret = 0

    if with_coverage:
        coverage.stop()
        modules = [
            mod for name, mod in sys.modules.iteritems()
            if name.startswith('pygments.') and mod
        ]
        coverage.report(modules)

    return ret


if __name__ == '__main__':
    with_coverage = False
    if sys.argv[1:2] == ['-C']:
        with_coverage = bool(coverage)
        del sys.argv[1]
    sys.exit(run_tests(with_coverage))
예제 #34
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