This file is indexed.

/usr/bin/pyruntest is in python-pyruntest 0.1+13.10.20130702-0ubuntu3.

This file is owned by root:root, with mode 0o755.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
#! /usr/bin/python
# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
# Copyright 2012 Canonical
# Author: Thomi Richards
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License version 3, as published
# by the Free Software Foundation.
#

"""A simple unit-test runner that 'Just Works' for the most common use cases."""

import argparse
from argparse import ArgumentParser
from contextlib import contextmanager
import logging
import sys
from testtools import iterate_tests
from unittest.loader import TestLoader
from unittest import TestSuite
import os


logger = logging.getLogger(__name__)
_output_descriptors = {
    '_output_stream':  None,
    '_formatted_output_stream': None
}


def main():
    args = parse_args()

    logging.basicConfig(stream=get_output_stream(args.output, '_output_stream'))
    test_suite = load_test_suite_from_name(args.suite)
    runner = construct_test_runner(args)
    success = runner.run(test_suite).wasSuccessful()
    if not success:
        exit(1)


def get_output_stream(output, name):
    global _output_descriptors

    if _output_descriptors[name] is None:
        if output:
            _output_descriptors[name] = open(output, 'w')
        else:
            _output_descriptors[name] = sys.stdout
    return _output_descriptors[name]


def patch_python_path():
    """Prepend the current directory to sys.path to ensure that we can
    load & run tests if the caller is in the parent directory.

    """
    if os.getcwd() not in sys.path:
        sys.path.insert(0, os.getcwd())


def load_test_suite_from_name(test_names):
    """Returns a test suite object given a dotted test names."""
    patch_python_path()
    loader = TestLoader()
    if isinstance(test_names, basestring):
        test_names = list(test_names)
    elif not isinstance(test_names, list):
        raise TypeError("test_names must be either a string or list, not %r"
                        % (type(test_names)))

    tests = []
    test_package_locations = []
    for test_name in test_names:
        top_level_pkg = test_name.split('.')[0]
        package = __import__(top_level_pkg)
        pkg_file = package.__file__
        if os.path.basename(pkg_file).startswith('__init__'):
            package_parent_path = os.path.abspath(
                os.path.join(
                    os.path.dirname(pkg_file),
                    '..'
                    )
                )
        else:
            package_parent_path = os.path.abspath(os.path.dirname(pkg_file))
        if package_parent_path not in test_package_locations:
            test_package_locations.append(package_parent_path)

        tests.append(loader.discover(top_level_pkg,
                                     top_level_dir=package_parent_path))
    all_tests = TestSuite(tests)

    test_dirs = ", ".join(sorted(test_package_locations))
    logger.info("Loading tests from: %s\n", test_dirs)

    requested_tests = {}
    for test in iterate_tests(all_tests):
        # The test loader returns tests that start with 'unittest.loader' if for
        # whatever reason the test failed to load. We run the tests without the
        # built-in exception catching turned on, so we can get at the raised
        # exception, which we print, so the user knows that something in their
        # tests is broken.
        if test.id().startswith('unittest.loader'):
            try:
                test.debug()
            except Exception as e:
                print e
        elif any([test.id().startswith(name) for name in test_names]):
            requested_tests[test.id()] = test

    return TestSuite(requested_tests.values())


def construct_test_runner(args):
    output_stream = get_output_stream(args.formatted_output, '_formatted_output_stream')

    kwargs = dict(stdout=output_stream,
        output_format=args.format
        )

    if 'coverage' in args:
        kwargs['coverage'] = args.coverage
        if 'cover_format' in args:
            kwargs['cover_format'] = args.cover_format
        if 'cover_output' in args:
            kwargs['cover_output'] = args.cover_output
        if 'cover_exclude' in args:
            kwargs['cover_exclude'] = args.cover_exclude
    return ConfigurableTestRunner(**kwargs)


class ConfigurableTestRunner(object):
    """A configurable test runner class.

    This class alows us to configure the output format and whether of not we
    collect coverage information for the test run.

    """

    def __init__(self, stdout, output_format, coverage=False, cover_format=None, cover_output='-', cover_exclude=''):
        self.stdout = stdout
        self.result_class = output_format
        self.coverage = coverage
        self.cover_format = cover_format
        self.cover_output = cover_output
        self.cover_exclude = cover_exclude.split(',')

    def run(self, test):
        "Run the given test case or test suite."
        result = self.result_class(self.stdout)
        result.startTestRun()
        try:
            if self.coverage:
                with enable_coverage(self.cover_output, self.cover_format, self.cover_exclude):
                    return test.run(result)
            else:
                return test.run(result)
        finally:
            result.stopTestRun()


@contextmanager
def enable_coverage(filename, format, exclude_list):
    """A context manager that enables coverage collection."""

    from coverage import coverage
    cov = coverage(omit=exclude_list,cover_pylib=True)
    cov.start()
    yield
    cov.stop()

    if format == 'xml':
        if not filename.endswith('.' + format):
            filename += '.xml'
        cov.xml_report(outfile=filename)
    elif format == 'html':
        cov.html_report(directory=filename)
    else:
        if not filename.endswith('.' + format):
            filename += '.txt'
        cov.report(file=open(filename, 'w'))


class FormatAction(argparse.Action):
    """An Argparse action that stores the output format class object."""

    supported_formats = []

    def __call__(self, parser, namespace, values, option_string=None):
        setattr(namespace, self.dest, self.supported_formats.get(values))


def parse_args():
    """Create the argument parser object, parse sys.stdout and return the result."""
    parser = ArgumentParser(description=__doc__)

    parser.add_argument('suite', nargs='+', help="Specify test suite(s) to run.")

    supported_formats = get_supported_output_formats()
    FormatAction.supported_formats = supported_formats

    parser.add_argument('-f', '--format', choices=supported_formats.keys(),
        action=FormatAction, default=supported_formats['text'],
        help="""Specify what format the test results should be presented in.""")
    parser.add_argument('-fo', '--formatted-output', type=str,
        help="""Specify where formatted output (e.g. xml) should go. If left
        unspecified, stdout is used.""")
    parser.add_argument('-o', '--output', help="""Specify the location where test
        output should go. If left unspecified, stdout is used.""")
    if have_coverage():
        parser.add_argument('-c', '--coverage', action='store_true', default=False,
            help="""Enable coverage collection for this test run.""")
        parser.add_argument('-cf', '--cover-format', type=str, choices=['html', 'xml', 'txt'],
            help="Specify coverage report format. Default is txt.", default='txt',
            dest='cover_format')
        parser.add_argument('-co', '--cover-output', type=str, default='coverage',
            help="Specify the file path where the coverage report should go. \
            The default is 'coverage.XXX'.", dest='cover_output')
        parser.add_argument('-ce', '--cover-exclude', type=str, help="Omit files \
        when their filename matches one of these patterns. Usually needs quoting \
        on the command line. Multiple patterns can be specified in a comma-separated \
        list.", dest='cover_exclude', default='')
    return parser.parse_args()


def get_supported_output_formats():
    """Return a dictionary mapping a short name to a Result object for each
    format we support.

    """
    formats = {}
    try:
        from testtools import TextTestResult
        formats['text'] = TextTestResult
    except:
        pass
    try:
        from junitxml import JUnitXmlResult
        formats['xml'] = JUnitXmlResult
    except:
        pass
    return formats


def have_coverage():
    """Return true if the coverage module is installed."""
    try:
        import coverage
        return True
    except ImportError:
        return False


if __name__ == '__main__':
    main()