Exemplo n.º 1
0
 def testTermcolorTrue(self):
     """
     termcolor=True results in terminal output
     """
     c = Colors(termcolor=True)
     self.assertTrue(c.termcolor)
     self.assertTrue(len(c.bold("")) > 0)
Exemplo n.º 2
0
 def testTermcolorFalse(self):
     """
     termcolor=False results in no terminal output
     """
     c = Colors(termcolor=False)
     self.assertFalse(c.termcolor)
     self.assertFalse(len(c.bold("")) > 0)
Exemplo n.º 3
0
 def testTermcolorTrue(self):
     """
     termcolor=True results in terminal output
     """
     c = Colors(termcolor=True)
     self.assertTrue(c.termcolor)
     self.assertTrue(len(c.bold("")) > 0)
Exemplo n.º 4
0
 def testTermcolorFalse(self):
     """
     termcolor=False results in no terminal output
     """
     c = Colors(termcolor=False)
     self.assertFalse(c.termcolor)
     self.assertFalse(len(c.bold("")) > 0)
Exemplo n.º 5
0
 def testUp(self):
     """
     calling up gives us a non-blank string
     """
     c = Colors()
     up = c.up()
     self.assertEqual(type(up), str)
     self.assertNotEqual(up, '')
Exemplo n.º 6
0
 def testUp(self):
     """
     calling up gives us a non-blank string
     """
     c = Colors()
     up = c.up()
     self.assertEqual(type(up), str)
     self.assertNotEqual(up, '')
Exemplo n.º 7
0
 def testTermstyleColorsDoNotCrash(self):
     "termstyle-based colors don't crash and output something"
     c = Colors(termcolor=True)
     for func in [c.bold, c.blue, c.green, c.red, c.yellow, c.passing,
             c.failing, c.error, c.skipped, c.unexpectedSuccess,
             c.expectedFailure, c.moduleName]:
         self.assertTrue(len(func("")) > 0)
     # c.className is a special case
     c.className("")
Exemplo n.º 8
0
 def testDisableWindowsTrue(self):
     """
     disable_windows=True: ANSI color codes are present in the stream
     """
     c = Colors(termcolor=True)
     s = StringIO()
     gs = GreenStream(s, disable_windows=True)
     msg = c.red("some colored string")
     gs.write(msg)
     self.assertEqual(len(gs.stream.getvalue()), len(msg))
Exemplo n.º 9
0
 def testHTMLColorsDoNotCrash(self):
     "termstyle-based colors don't crash and output something"
     c = Colors(html=True)
     for func in [c.bold, c.blue, c.green, c.red, c.yellow, c.passing,
             c.failing, c.error, c.skipped, c.unexpectedSuccess,
             c.expectedFailure, c.moduleName]:
         self.assertTrue(len(func("")) > 0, "%r is not producing output" % func)
         self.assertTrue('span' in func(""))
     # c.className is a special case
     c.className("")
Exemplo n.º 10
0
 def testDisableWindowsTrue(self):
     """
     disable_windows=True: ANSI color codes are present in the stream
     """
     c = Colors(termcolor=True)
     s = StringIO()
     gs = GreenStream(s, disable_windows=True)
     msg = c.red("some colored string")
     gs.write(msg)
     self.assertEqual(len(gs.stream.getvalue()), len(msg))
Exemplo n.º 11
0
 def testTermstyleColorsDoNotCrash(self):
     """
     termstyle-based colors don't crash and output something
     """
     c = Colors(termcolor=True)
     for func in [c.bold, c.blue, c.green, c.red, c.yellow, c.passing,
             c.failing, c.error, c.skipped, c.unexpectedSuccess,
             c.expectedFailure, c.moduleName]:
         self.assertTrue(len(func("")) > 0)
     # c.className is a special case
     c.className("")
Exemplo n.º 12
0
 def testDisableWindowsFalse(self):
     """
     disable_windows=False: Colorama strips ANSI color codes from the stream
     """
     c = Colors(termcolor=True)
     s = StringIO()
     gs = GreenStream(s, override_appveyor=True, disable_windows=False)
     colored_msg = c.red("a")
     gs.write(colored_msg)
     import colorama
     self.assertTrue(
         issubclass(type(gs.stream), colorama.ansitowin32.StreamWrapper))
Exemplo n.º 13
0
 def testDisableWindowsFalse(self):
     """
     disable_windows=False: Colorama strips ANSI color codes from the stream
     """
     c = Colors(termcolor=True)
     s = StringIO()
     gs = GreenStream(s, override_appveyor=True, disable_windows=False)
     colored_msg = c.red("a")
     gs.write(colored_msg)
     import colorama
     self.assertTrue(issubclass(type(gs.stream),
                     colorama.ansitowin32.StreamWrapper))
Exemplo n.º 14
0
 def test_displayStderr(self):
     """
     displayStderr displays captured stderr
     """
     stream = StringIO()
     noise = "blah blah blah"
     btr = BaseTestResult(stream, Colors(False))
     pt = ProtoTest()
     btr.stderr_errput[pt] = noise
     btr.displayStderr(pt)
     self.assertIn(noise, stream.getvalue())
Exemplo n.º 15
0
 def __init__(self, args, stream):
     super(GreenTestResult, self).__init__(stream, Colors(args.termcolor))
     self.args = args
     self.showAll       = args.verbose > 1
     self.dots          = args.verbose == 1
     self.verbose       = args.verbose
     self.last_module   = ''
     self.last_class    = ''
     self.failfast      = args.failfast
     self.shouldStop    = False
     self.testsRun      = 0
     # Individual lists
     self.errors              = []
     self.expectedFailures    = []
     self.failures            = []
     self.passing             = []
     self.skipped             = []
     self.unexpectedSuccesses = []
     # Combination of all errors and failures
     self.all_errors = []
Exemplo n.º 16
0
 def __init__(self, args, stream):
     super(GreenTestResult, self).__init__(stream, Colors(args.termcolor))
     self.args = args
     self.showAll = args.verbose > 1
     self.dots = args.verbose == 1
     self.verbose = args.verbose
     self.last_module = ""
     self.last_class = ""
     self.first_text_output = ""
     self.failfast = args.failfast
     self.shouldStop = False
     self.testsRun = 0
     # Individual lists
     self.errors = []
     self.expectedFailures = []
     self.failures = []
     self.passing = []
     self.skipped = []
     self.unexpectedSuccesses = []
     # Combination of all errors and failures
     self.all_errors = []
     # For exiting non-zero if we don't reach a certain level of coverage
     self.coverage_percent = None
Exemplo n.º 17
0
 def __init__(self, stream, descriptions, verbosity, html=False,
         termcolor=None):
     """stream, descriptions, and verbosity are as in
     unittest.runner.TextTestRunner.
     """
     self.stream       = stream
     self.showAll      = verbosity > 1
     self.dots         = verbosity == 1
     self.verbosity    = verbosity
     self.descriptions = descriptions
     self.colors       = Colors(termcolor, html)
     self.last_module  = ''
     self.last_class   = ''
     self.shouldStop   = False
     self.testsRun     = 0
     # Individual lists
     self.errors              = []
     self.expectedFailures    = []
     self.failures            = []
     self.passing             = []
     self.skipped             = []
     self.unexpectedSuccesses = []
     # Combination of all errors and failures
     self.all_errors = []
Exemplo n.º 18
0
 def testEnableHTML(self):
     "html=True causes HTML output"
     c = Colors(html=True)
     self.assertEqual(c.bold(''),  '<span style="color: rgb(255,255,255);"></span>')
Exemplo n.º 19
0
class GreenTestResult():
    "Aggregates test results and outputs them to a stream."


    def __init__(self, stream, descriptions, verbosity, html=False,
            termcolor=None):
        """stream, descriptions, and verbosity are as in
        unittest.runner.TextTestRunner.
        """
        self.stream       = stream
        self.showAll      = verbosity > 1
        self.dots         = verbosity == 1
        self.verbosity    = verbosity
        self.descriptions = descriptions
        self.colors       = Colors(termcolor, html)
        self.last_module  = ''
        self.last_class   = ''
        self.shouldStop   = False
        self.testsRun     = 0
        # Individual lists
        self.errors              = []
        self.expectedFailures    = []
        self.failures            = []
        self.passing             = []
        self.skipped             = []
        self.unexpectedSuccesses = []
        # Combination of all errors and failures
        self.all_errors = []


    def addProtoTestResult(self, protoTestResult):
        for test, err in protoTestResult.errors:
            self.addError(test, err)
        for test, err in protoTestResult.expectedFailures:
            self.addExpectedFailure(test, err)
        for test, err in protoTestResult.failures:
            self.addFailure(test, err)
        for test in protoTestResult.passing:
            self.addSuccess(test)
        for test, reason in protoTestResult.skipped:
            self.addSkip(test, reason)
        for test in protoTestResult.unexpectedSuccesses:
            self.addUnexpectedSuccess(test)


    def startTestRun(self):
        "Called once before any tests run"
        self.startTime = time.time()
        # Really verbose information
        if self.colors.html:
            self.stream.write(
                    '<div style="font-family: Monaco, \'Courier New\', monospace; color: rgb(170,170,170); background: rgb(0,0,0); padding: 14px;">')
        if self.verbosity > 2:
            self.stream.writeln(self.colors.bold(pretty_version() + "\n"))


    def stopTestRun(self):
        "Called once after all tests have run"
        self.stopTime = time.time()
        self.timeTaken = self.stopTime - self.startTime
        self.printErrors()
        if self.testsRun:
            self.stream.writeln()
        self.stream.writeln("Ran %s test%s in %ss" %
            (self.colors.bold(str(self.testsRun)),
            self.testsRun != 1 and "s" or "",
            self.colors.bold("%.3f" % self.timeTaken)))
        self.stream.writeln()
        results = [
            (self.errors, 'errors', self.colors.error),
            (self.expectedFailures, 'expected_failures',
                self.colors.expectedFailure),
            (self.failures, 'failures', self.colors.failing),
            (self.passing, 'passes', self.colors.passing),
            (self.skipped, 'skips', self.colors.skipped),
            (self.unexpectedSuccesses, 'unexpected_successes',
                self.colors.unexpectedSuccess),
        ]
        stats = []
        for obj_list, name, color_func in results:
            if obj_list:
                stats.append("{}={}".format(name, color_func(str(len(obj_list)))))
        if not stats:
            self.stream.writeln(self.colors.passing("No Tests Found"))
        else:
            grade = self.colors.passing('OK')
            if self.errors or self.failures:
                grade = self.colors.failing('FAILED')
            self.stream.writeln("{} ({})".format(grade, ', '.join(stats)))
        if self.colors.html:
            self.stream.writeln('</div>')


    def startTest(self, test):
        "Called before the start of each test"
        self.testsRun += 1

        # Get our bearings
        test = proto_test(test)
        current_module = test.module
        current_class  = test.class_name

        # Output
        if self.showAll:
            # Module...if it changed.
            if current_module != self.last_module:
                self.stream.writeln(self.colors.moduleName(current_module))
            # Class...if it changed.
            if current_class != self.last_class:
                self.stream.writeln(self.colors.className(
                    self.stream.formatText(current_class, indent=1)))
            # Test name or description
            if not self.colors.html:
                # In the terminal, we will write a placeholder, and then
                # rewrite it in color after the test has run.
                self.stream.write(
                    self.colors.bold(
                        self.stream.formatLine(
                            test.getDescription(self.verbosity),
                            indent=2)))
            self.stream.flush()

        # Set state for next time
        if current_module != self.last_module:
            self.last_module = current_module
        if current_class != self.last_class:
            self.last_class = current_class


    def stopTest(self, test):
        "Called after the end of each test"


    def _reportOutcome(self, test, outcome_char, color_func, err=None,
            reason=''):
        test = proto_test(test)
        if self.showAll:
            # Move the cursor back to the start of the line in terminal mode
            if not self.colors.html:
                self.stream.write('\r')
            # Escape the HTML that may be in the docstring
            test_description = test.getDescription(self.verbosity)
            if self.colors.html:
                test_description = escape(test_description)
            self.stream.write(
                color_func(
                    self.stream.formatLine(
                        test_description,
                        indent=2,
                        outcome_char=outcome_char)
                )
            )
            if reason:
                self.stream.write(color_func(' -- ' + reason))
            self.stream.writeln()
            self.stream.flush()
        elif self.dots:
            self.stream.write(color_func(outcome_char))
            self.stream.flush()


    def addSuccess(self, test):
        "Called when a test passed"
        test = proto_test(test)
        self.passing.append(test)
        self._reportOutcome(test, '.', self.colors.passing)


    def addError(self, test, err):
        "Called when a test raises an exception"
        test = proto_test(test)
        err = proto_error(err)
        self.errors.append((test, err))
        self.all_errors.append((test, self.colors.error, 'Error', err))
        self._reportOutcome(test, 'E', self.colors.error, err)


    def addFailure(self, test, err):
        "Called when a test fails a unittest assertion"
        test = proto_test(test)
        err = proto_error(err)
        self.failures.append((test, err))
        self.all_errors.append((test, self.colors.error, 'Failure', err))
        self._reportOutcome(test, 'F', self.colors.failing, err)


    def addSkip(self, test, reason):
        test = proto_test(test)
        "Called when a test is skipped"
        self.skipped.append((test, reason))
        self._reportOutcome(
                test, 's', self.colors.skipped, reason=reason)


    def addExpectedFailure(self, test, err):
        "Called when a test fails, and we expeced the failure"
        test = proto_test(test)
        err = proto_error(err)
        self.expectedFailures.append((test, err))
        self._reportOutcome(test, 'x', self.colors.expectedFailure, err)


    def addUnexpectedSuccess(self, test):
        "Called when a test passed, but we expected a failure"
        test = proto_test(test)
        self.unexpectedSuccesses.append(test)
        self._reportOutcome(test, 'u', self.colors.unexpectedSuccess)


    def printErrors(self):
        "Print a list of all tracebacks from errors and failures"
        if not self.all_errors:
            return
        if self.dots:
            self.stream.writeln()
        for (test, color_func, outcome, err) in self.all_errors:
            # Header Line
            self.stream.writeln(
                    '\n' + color_func(outcome) +
                    ' in ' + self.colors.bold(test.dotted_name))

            # Frame Line
            relevant_frames = []
            for i, frame in enumerate(err.traceback_lines):
                debug('\n' + '*' * 30 + "Frame {}:".format(i) + '*' * 30
                      + "\n{}".format(self.colors.yellow(frame)), level = 3)
                # Ignore useless frames
                if self.verbosity < 4:
                    if frame.strip() == "Traceback (most recent call last):":
                        continue
                reindented_lines = []
                # If we're in html, space-based indenting needs to be converted.
                if self.colors.html:
                    for line in frame.split('\n'):
                        frame_indent = 0
                        while line[:2] == '  ':
                            line = line[2:]
                            frame_indent += 1
                        line = self.stream.formatLine(line, indent=frame_indent)
                        reindented_lines.append(line)
                    frame = "\n".join(reindented_lines)
                # Done with this frame, capture it.
                relevant_frames.append(frame)
            self.stream.write(''.join(relevant_frames))


    def wasSuccessful(self):
        "Tells whether or not the overall run was successful"
        return len(self.all_errors) == 0
Exemplo n.º 20
0
 def testTermcolorAuto(self):
     """
     termcolor=None causes termcolor autodetected and set to True or False
     """
     c = Colors()
     self.assertTrue(c.termcolor in [True, False])