예제 #1
0
 def test_wasSuccessful(self):
     "wasSuccessful returns what we expect"
     self.args.verbose = 1
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     self.assertEqual(gtr.wasSuccessful(), True)
     gtr.all_errors.append('anything')
     self.assertEqual(gtr.wasSuccessful(), False)
예제 #2
0
 def test_reportOutcome(self):
     """
     _reportOutcome contains output we expect
     """
     gtr = GreenTestResult(GreenStream(self.stream), None, 1)
     gtr._reportOutcome(None, '.', lambda x: x)
     self.assertIn('.', self.stream.getvalue())
예제 #3
0
 def test_wasSuccessful_coverageFails(self):
     """
     wasSuccessful fails if minimum coverage is not met
     """
     self.args.minimum_coverage = 50
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     gtr.coverage_percent = 49
     self.assertEqual(gtr.wasSuccessful(), False)
예제 #4
0
 def test_wasSuccessful_unexpectedSuccesses(self):
     """
     wasSuccessful returns what we expect when we only have unexpectedSuccesses
     """
     self.args.verbose = 1
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     gtr.unexpectedSuccesses.append('anything')
     self.assertEqual(gtr.wasSuccessful(), True)
예제 #5
0
 def test_wasSuccessful_skipped(self):
     """
     wasSuccessful returns what we expect when we only have skipped tests
     """
     self.args.verbose = 1
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     gtr.skipped.append("anything")
     self.assertEqual(gtr.wasSuccessful(), True)
예제 #6
0
 def test_wasSuccessful_coverageFails(self):
     """
     wasSuccessful fails if minimum coverage is not met
     """
     self.args.minimum_coverage = 50
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     gtr.coverage_percent = 49
     self.assertEqual(gtr.wasSuccessful(), False)
예제 #7
0
 def test_reportOutcome(self):
     """
     _reportOutcome contains output we expect.
     """
     self.args.verbose = 1
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     gtr._reportOutcome(None, '.', lambda x: x)
     self.assertIn('.', self.stream.getvalue())
예제 #8
0
 def test_reportOutcomeVerbose(self):
     "_reportOutcome contains output we expect in verbose mode"
     gtr = GreenTestResult(GreenStream(self.stream), None, 2)
     r = 'a fake reason'
     t = MagicMock()
     t.__str__.return_value = 'junk'
     gtr._reportOutcome(t, '.', lambda x: x, None, r)
     self.assertTrue(r in self.stream.getvalue())
예제 #9
0
 def test_reportOutcome(self):
     """
     _reportOutcome contains output we expect.
     """
     self.args.verbose = 1
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     gtr._reportOutcome(None, '.', lambda x: x)
     self.assertIn('.', self.stream.getvalue())
예제 #10
0
 def test_wasSuccessful_unexpectedSuccesses(self):
     """
     wasSuccessful returns what we expect when we only have unexpectedSuccesses
     """
     self.args.verbose = 1
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     gtr.unexpectedSuccesses.append('anything')
     self.assertEqual(gtr.wasSuccessful(), True)
예제 #11
0
 def test_wasSuccessful_coverageSucceeds(self):
     """
     wasSuccessful succeds if minimum coverage is met
     """
     self.args.minimum_coverage = 50
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     gtr.passing.append("anything")
     gtr.coverage_percent = 60
     self.assertEqual(gtr.wasSuccessful(), True)
예제 #12
0
 def test_wasSuccessful_coverageSucceeds(self):
     """
     wasSuccessful succeds if minimum coverage is met
     """
     self.args.minimum_coverage = 50
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     gtr.passing.append('anything')
     gtr.coverage_percent = 60
     self.assertEqual(gtr.wasSuccessful(), True)
예제 #13
0
 def test_wasSuccessful(self):
     """
     wasSuccessful returns what we expect
     """
     self.args.verbose = 1
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     self.assertEqual(gtr.wasSuccessful(), True)
     gtr.all_errors.append('anything')
     self.assertEqual(gtr.wasSuccessful(), False)
예제 #14
0
    def test_stopTestRun_singular_process_message(self):
        """
        StopTestRun adds correct summary when one process is used
        """
        self.args.processes = 1
        gtr = GreenTestResult(self.args, GreenStream(self.stream))
        gtr.startTestRun()
        gtr.stopTestRun()

        self.assertIn("using 1 process\n", self.stream.getvalue())
예제 #15
0
    def test_stopTestRun_processes_message(self):
        """
        StopTestRun adds number of processes used to summary
        """
        self.args.processes = 4
        gtr = GreenTestResult(self.args, GreenStream(self.stream))
        gtr.startTestRun()
        gtr.stopTestRun()

        self.assertIn("using 4 processes\n", self.stream.getvalue())
예제 #16
0
    def setUp(self):
        self._destination = StringIO()
        self._test_results = GreenTestResult(default_args,
                                             GreenStream(StringIO()))
        self._adapter = JUnitXML()

        self._test = ProtoTest()
        self._test.module = "my_module"
        self._test.class_name = "MyClass"
        self._test.method_name = "my_method"
예제 #17
0
 def test_failfastAddUnexpectedSuccess(self):
     """
     addUnexpectedSuccess no longer triggers failfast when it is set
     """
     self.args.failfast = True
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     self.assertEqual(gtr.failfast, True)
     self.assertEqual(gtr.shouldStop, False)
     gtr.addUnexpectedSuccess(MyProtoTest())
     self.assertEqual(gtr.shouldStop, False)
예제 #18
0
 def test_failfastAddUnexpectedSuccess(self):
     """
     addUnexpectedSuccess triggers failfast when it is set
     """
     self.args.failfast = True
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     self.assertEqual(gtr.failfast, True)
     self.assertEqual(gtr.shouldStop, False)
     gtr.addUnexpectedSuccess(MyProtoTest())
     self.assertEqual(gtr.shouldStop, True)
예제 #19
0
 def test_printErrorsSkipreport(self):
     """
     printErrors() prints the skip report.
     """
     self.args.verbose = 1
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     pt = MyProtoTest()
     reason = "dog ate homework"
     gtr.addSkip(pt, reason)
     gtr.printErrors()
     self.assertIn(reason, self.stream.getvalue())
예제 #20
0
 def _outputFromVerboseTest(self):
     """
     Start a test with verbose = 2 and get its output.
     """
     class FakeCase(unittest.TestCase):
         def runTest(self):
             pass
     self.args.verbose = 2
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     tc = FakeCase()
     gtr.startTest(tc)
     output = self.stream.getvalue()
     return output.split('\n')
예제 #21
0
 def _outputFromVerboseTest(self):
     """
     Start a test with verbose = 2 and get its output.
     """
     class FakeCase(unittest.TestCase):
         def runTest(self):
             pass
     self.args.verbose = 2
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     tc = FakeCase()
     gtr.startTest(tc)
     output = self.stream.getvalue()
     return output.split('\n')
예제 #22
0
 def test_failfastAddFailure(self):
     """
     addFailure triggers failfast when it is set
     """
     self.args.failfast = True
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     self.assertEqual(gtr.failfast, True)
     try:
         raise Exception
     except:
         err = sys.exc_info()
     self.assertEqual(gtr.shouldStop, False)
     gtr.addFailure(MyProtoTest(), proto_error(err))
     self.assertEqual(gtr.shouldStop, True)
예제 #23
0
    def test_tryRecordingStdoutStderr(self):
        """
        Recording stdout and stderr works correctly.
        """
        gtr = GreenTestResult(self.args, GreenStream(self.stream))
        gtr.recordStdout = MagicMock()
        gtr.recordStderr = MagicMock()

        output = 'apple'
        test1 = MagicMock()
        ptr1 = MagicMock()
        ptr1.stdout_output = {test1:output}
        ptr1.stderr_errput = {}

        errput = 'banana'
        test2 = MagicMock()
        ptr2 = MagicMock()
        ptr2.stdout_output = {}
        ptr2.stderr_errput = {test2:errput}


        gtr.tryRecordingStdoutStderr(test1, ptr1)
        gtr.recordStdout.assert_called_with(test1, output)
        gtr.tryRecordingStdoutStderr(test2, ptr2)
        gtr.recordStderr.assert_called_with(test2, errput)
예제 #24
0
    def test_tryRecordingStdoutStderr_SubTest(self):
        """
        Recording stdout and stderr works correctly for failed/errored SubTests.
        """
        gtr = GreenTestResult(self.args, GreenStream(self.stream))
        gtr.recordStdout = MagicMock()
        gtr.recordStderr = MagicMock()

        output = "apple"
        test1 = MagicMock()
        test1.dotted_name = "test 1"
        subtest1 = MagicMock()
        subtest1.dotted_name = "test 1: the subtest"
        subtest1.class_name = "SubTest"
        ptr1 = MagicMock()
        ptr1.stdout_output = {test1: output}
        ptr1.stderr_errput = {}

        errput = "banana"
        test2 = MagicMock()
        test2.dotted_name = "test 2"
        subtest2 = MagicMock()
        subtest2.dotted_name = "test 2: subtests are annoying"
        subtest2.class_name = "SubTest"
        ptr2 = MagicMock()
        ptr2.stdout_output = {}
        ptr2.stderr_errput = {test2: errput}

        gtr.tryRecordingStdoutStderr(subtest1, ptr1, err=True)
        gtr.recordStdout.assert_called_with(subtest1, output)
        gtr.tryRecordingStdoutStderr(subtest2, ptr2, err=True)
        gtr.recordStderr.assert_called_with(subtest2, errput)
예제 #25
0
 def test_printErrorsDots(self):
     "printErrors() looks correct in verbose=1 (dots) mode"
     try:
         raise Exception
     except:
         err = sys.exc_info()
     gtr = GreenTestResult(GreenStream(self.stream), None, 1)
     test = MagicMock()
     gtr.addError(test, proto_error(err))
     gtr.printErrors()
     self.assertTrue('\n\n' in self.stream.getvalue())
     self.assertTrue('test_printErrorsDots' in self.stream.getvalue())
     self.assertTrue('raise Exception' in self.stream.getvalue())
     self.assertTrue('Error' in self.stream.getvalue())
예제 #26
0
    def test_stopTestRun(self, mock_printErrors):
        """
        We ignore coverage's error about not having anything to cover.
        """
        self.args.cov = MagicMock()
        self.args.cov.stop = MagicMock(
                side_effect=CoverageException('Different Exception'))
        self.args.run_coverage = True
        gtr = GreenTestResult(self.args, GreenStream(self.stream))
        gtr.startTestRun()
        self.assertRaises(CoverageException, gtr.stopTestRun)

        self.args.cov.stop = MagicMock(
                side_effect=CoverageException('No data to report'))
예제 #27
0
 def test_failfastAddFailure(self):
     """
     addFailure triggers failfast when it is set
     """
     self.args.failfast = True
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     self.assertEqual(gtr.failfast, True)
     try:
         raise Exception
     except:
         err = sys.exc_info()
     self.assertEqual(gtr.shouldStop, False)
     gtr.addFailure(MyProtoTest(), proto_error(err))
     self.assertEqual(gtr.shouldStop, True)
예제 #28
0
    def test_stopTestRun(self, mock_printErrors):
        """
        We ignore coverage's error about not having anything to cover.
        """
        self.args.cov = MagicMock()
        self.args.cov.stop = MagicMock(
                side_effect=CoverageException('Different Exception'))
        self.args.run_coverage = True
        gtr = GreenTestResult(self.args, GreenStream(self.stream))
        gtr.startTestRun()
        self.assertRaises(CoverageException, gtr.stopTestRun)

        self.args.cov.stop = MagicMock(
                side_effect=CoverageException('No data to report'))
예제 #29
0
 def test_printErrorsNoTracebacks(self):
     """
     printErrors() omits tracebacks for failures and errors when
     no_tracebacks is True
     """
     self.args.no_tracebacks = True
     try:
         raise Exception
     except:
         err = sys.exc_info()
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     pt = MyProtoTest()
     gtr.addError(pt, proto_error(err))
     gtr.printErrors()
     self.assertNotIn("Exception", self.stream.getvalue())
예제 #30
0
 def test_reportOutcomeVerbose(self):
     """
     _reportOutcome contains output we expect in verbose mode
     """
     self.args.verbose = 2
     def isatty():
         return True
     gs = GreenStream(self.stream)
     gs.isatty = isatty
     gtr = GreenTestResult(self.args, gs)
     r = 'a fake reason'
     t = MagicMock()
     t.__str__.return_value = 'junk'
     gtr._reportOutcome(t, '.', lambda x: x, None, r)
     self.assertIn(r, self.stream.getvalue())
예제 #31
0
 def test_reportOutcomeVerboseHTML(self):
     "html=True causes _reportOutcome() to escape HTML in docstrings"
     gtr = GreenTestResult(GreenStream(self.stream), None, 3)
     gtr.colors.html = True
     r = 'a fake reason'
     t = MagicMock()
     t.shortDescription.return_value = 'a fake test output line &nbsp; <>'
     gtr._reportOutcome(t, '.', lambda x: x, None, r)
     self.assertTrue(r in self.stream.getvalue())
     self.assertTrue('&amp;' in self.stream.getvalue())
     self.assertTrue('&lt;' in self.stream.getvalue())
     self.assertTrue('&gt;' in self.stream.getvalue())
     self.assertFalse('&nbsp;' in self.stream.getvalue())
     self.assertFalse('<' in self.stream.getvalue())
     self.assertFalse('>' in self.stream.getvalue())
예제 #32
0
 def test_printErrorsVerbose3(self):
     """
     printErrors() looks correct in verbose=3 mode
     """
     try:
         raise Exception
     except:
         err = sys.exc_info()
     gtr = GreenTestResult(GreenStream(self.stream), None, 3, False, False)
     gtr.addError(MyProtoTest(), proto_error(err))
     gtr.printErrors()
     self.assertIn('\n\n', self.stream.getvalue())
     self.assertIn('my_module.MyClass.myMethod', self.stream.getvalue())
     self.assertIn('test_printErrorsVerbose3', self.stream.getvalue())
     self.assertIn('raise Exception', self.stream.getvalue())
     self.assertIn('Error', self.stream.getvalue())
예제 #33
0
 def test_reportOutcomeCursorUp(self):
     """
     _reportOutcome moves the cursor up when it needs to
     """
     self.args.verbose = 2
     def isatty():
         return True
     gs = GreenStream(self.stream)
     gs.isatty = isatty
     gtr = GreenTestResult(self.args, gs)
     r = 'a fake reason'
     t = MagicMock()
     t.__str__.return_value = 'x' * 1000
     gtr._reportOutcome(t, '.', lambda x: x, None, r)
     self.assertIn(r, self.stream.getvalue())
     self.assertLess(len(self.stream.getvalue()), 2000)
예제 #34
0
 def test_reportOutcomeCursorUp(self):
     """
     _reportOutcome moves the cursor up when it needs to
     """
     self.args.verbose = 2
     def isatty():
         return True
     gs = GreenStream(self.stream)
     gs.isatty = isatty
     gtr = GreenTestResult(self.args, gs)
     r = 'a fake reason'
     t = MagicMock()
     t.__str__.return_value = 'x' * 1000
     gtr._reportOutcome(t, '.', lambda x: x, None, r)
     self.assertIn(r, self.stream.getvalue())
     self.assertLess(len(self.stream.getvalue()), 2000)
예제 #35
0
    def test_addProtoTestResult(self):
        """
        addProtoTestResult adds the correct things to the correct places.
        """
        ptr = ProtoTestResult()

        err_t = proto_test(MagicMock())
        try:
            raise Exception
        except:
            err_e = proto_error(sys.exc_info())
        ptr.addError(err_t, err_e)

        ef_t = proto_test(MagicMock())
        try:
            raise Exception
        except:
            ef_e = proto_error(sys.exc_info())
        ptr.addExpectedFailure(ef_t, ef_e)

        fail_t = proto_test(MagicMock())
        try:
            raise Exception
        except:
            fail_e = proto_error(sys.exc_info())
        ptr.addFailure(fail_t, fail_e)

        pass_t = proto_test(MagicMock())
        ptr.addSuccess(pass_t)

        skip_t = proto_test(MagicMock())
        skip_r = proto_test(MagicMock())
        ptr.addSkip(skip_t, skip_r)

        us_t = proto_test(MagicMock())
        ptr.addUnexpectedSuccess(us_t)

        self.args.verbose = 0
        gtr = GreenTestResult(self.args, GreenStream(self.stream))
        gtr.addProtoTestResult(ptr)

        self.assertEqual(gtr.errors, [(err_t, err_e)])
        self.assertEqual(gtr.expectedFailures, [(ef_t, ef_e)])
        self.assertEqual(gtr.failures, [(fail_t, fail_e)])
        self.assertEqual(gtr.passing, [pass_t])
        self.assertEqual(gtr.skipped, [(skip_t, skip_r)])
        self.assertEqual(gtr.unexpectedSuccesses, [us_t])
예제 #36
0
    def test_addProtoTestResult(self):
        """
        addProtoTestResult adds the correct things to the correct places.
        """
        ptr = ProtoTestResult()

        err_t = proto_test(MagicMock())
        try:
            raise Exception
        except:
            err_e = proto_error(sys.exc_info())
        ptr.addError(err_t, err_e)

        ef_t = proto_test(MagicMock())
        try:
            raise Exception
        except:
            ef_e = proto_error(sys.exc_info())
        ptr.addExpectedFailure(ef_t, ef_e)

        fail_t = proto_test(MagicMock())
        try:
            raise Exception
        except:
            fail_e = proto_error(sys.exc_info())
        ptr.addFailure(fail_t, fail_e)

        pass_t = proto_test(MagicMock())
        ptr.addSuccess(pass_t)

        skip_t = proto_test(MagicMock())
        skip_r = proto_test(MagicMock())
        ptr.addSkip(skip_t, skip_r)

        us_t = proto_test(MagicMock())
        ptr.addUnexpectedSuccess(us_t)

        self.args.verbose = 0
        gtr = GreenTestResult(self.args, GreenStream(self.stream))
        gtr.addProtoTestResult(ptr)

        self.assertEqual(gtr.errors, [(err_t, err_e)])
        self.assertEqual(gtr.expectedFailures, [(ef_t, ef_e)])
        self.assertEqual(gtr.failures, [(fail_t, fail_e)])
        self.assertEqual(gtr.passing, [pass_t])
        self.assertEqual(gtr.skipped, [(skip_t, skip_r)])
        self.assertEqual(gtr.unexpectedSuccesses, [us_t])
예제 #37
0
 def _outputFromTest(self, args):
     class FakeCase(unittest.TestCase):
         def runTest(self):
             pass
     gtr = GreenTestResult(args, GreenStream(self.stream))
     gtr.startTestRun()
     gtr.startTest(FakeCase())
     gtr.stopTestRun()
     output = self.stream.getvalue()
     return output.split('\n')
예제 #38
0
파일: runner.py 프로젝트: svisser/green
    def run(self, suite):
        "Run the given test case or test suite."
        result = GreenTestResult(
                self.stream, self.descriptions, self.verbosity, html=self.html,
                termcolor=self.termcolor)
        registerResult(result)
        with warnings.catch_warnings():
            if self.warnings:
                # if self.warnings is set, use it to filter all the warnings
                warnings.simplefilter(self.warnings)
                # if the filter is 'default' or 'always', special-case the
                # warnings from the deprecated unittest methods to show them
                # no more than once per module, because they can be fairly
                # noisy.  The -Wd and -Wa flags can be used to bypass this
                # only when self.warnings is None.
                if self.warnings in ['default', 'always']:
                    warnings.filterwarnings('module',
                            category=DeprecationWarning,
                            message='Please use assert\w+ instead.')

            result.startTestRun()

            if self.subprocesses == 1:
                suite.run(result)
            else:
                tests = toProtoTestList(suite)
                pool = LoggingDaemonlessPool(processes=self.subprocesses)
                if tests:
                    async_responses = []
                    for index, test in enumerate(tests):
                        if self.run_coverage:
                            coverage_number = index + 1
                        else:
                            coverage_number = None
                        async_responses.append(pool.apply_async(
                            poolRunner,
                            (test.dotted_name, coverage_number, self.omit)))
                    pool.close()
                    for test, async_response in zip(tests, async_responses):
                        # Prints out the white 'processing...' version of the output
                        result.startTest(test)
                        # This blocks until the worker who is processing this
                        # particular test actually finishes
                        result.addProtoTestResult(async_response.get())
                pool.terminate()
                pool.join()

            result.stopTestRun()

        return result
예제 #39
0
    def test_stopTestRun(self, mock_printErrors):
        """
        We ignore coverage's error about not having anything to cover.
        """
        try:
            from coverage.misc import CoverageException
        except:
            self.skipTest("Coverage needs to be installed for this test.")
        self.args.cov = MagicMock()
        self.args.cov.stop = MagicMock(
                side_effect=CoverageException('Different Exception'))
        self.args.run_coverage = True
        gtr = GreenTestResult(self.args, GreenStream(self.stream))
        gtr.startTestRun()
        self.assertRaises(CoverageException, gtr.stopTestRun)

        self.args.cov.stop = MagicMock(
                side_effect=CoverageException('No data to report'))
예제 #40
0
 def test_startTestVerbose(self):
     "startTest() contains output we expect in verbose mode"
     class FakeCase(unittest.TestCase):
         def runTest(self):
             pass
     gtr = GreenTestResult(GreenStream(self.stream), None, 2)
     tc = FakeCase()
     gtr.startTest(tc)
     output = self.stream.getvalue()
     output_lines = output.split('\n')
     # Output should look like (I'm not putting the termcolor formatting here)
     # green.test.test_runner
     #   FakeCase
     #     test_it
     self.assertEqual(len(output_lines), 3)
     self.assertFalse(' ' in output_lines[0])
     self.assertTrue('  ' in output_lines[1])
     self.assertTrue('    ' in output_lines[2])
예제 #41
0
 def test_printErrors_Py2Unicode(self):
     """
     printErrors() doesn't crash in Python 2 when tracebacks contain unicode
     """
     try:
         raise Exception(u'Das Böse ist immer und überall')
     except:
         err = sys.exc_info()
     self.args.verbose = 1
     self.args.termcolor = False
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     gtr.addError(MyProtoTest(), proto_error(err))
     gtr.printErrors() # We shouldn't hit an exception here
     self.assertIn('\n\n', self.stream.getvalue())
     self.assertIn('my_module.MyClass.myMethod', self.stream.getvalue())
     self.assertIn('raise Exception', self.stream.getvalue())
     self.assertIn('Error', self.stream.getvalue())
     self.assertIn('Böse', self.stream.getvalue())
예제 #42
0
    def test_stopTestRun(self, mock_printErrors):
        """
        We ignore coverage's error about not having anything to cover.
        """
        try:
            from coverage.misc import CoverageException
        except:
            self.skipTest("Coverage needs to be installed for this test.")
        self.args.cov = MagicMock()
        self.args.cov.stop = MagicMock(
                side_effect=CoverageException('Different Exception'))
        self.args.run_coverage = True
        gtr = GreenTestResult(self.args, GreenStream(self.stream))
        gtr.startTestRun()
        self.assertRaises(CoverageException, gtr.stopTestRun)

        self.args.cov.stop = MagicMock(
                side_effect=CoverageException('No data to report'))
예제 #43
0
 def test_printErrorsVerbose2(self):
     """
     printErrors() looks correct in verbose=2 mode.
     """
     try:
         raise Exception
     except:
         err = sys.exc_info()
     self.args.verbose = 2
     self.args.termcolor = False
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     gtr.addError(MyProtoTest(), proto_error(err))
     gtr.printErrors()
     self.assertIn('\n\n', self.stream.getvalue())
     self.assertIn('my_module.MyClass.myMethod', self.stream.getvalue())
     self.assertIn('test_printErrorsVerbose2', self.stream.getvalue())
     self.assertIn('raise Exception', self.stream.getvalue())
     self.assertIn('Error', self.stream.getvalue())
예제 #44
0
 def test_reportOutcomeVerboseHTML(self):
     """
     html=True causes _reportOutcome() to escape HTML in docstrings
     """
     gtr = GreenTestResult(GreenStream(self.stream), None, 3)
     gtr.colors.html = True
     r = 'a fake reason'
     class Injection(unittest.TestCase):
         def test_method(self):
             'a fake test output line &nbsp; <>'
     t = proto_test(Injection('test_method'))
     gtr._reportOutcome(t, '.', lambda x: x, None, r)
     self.assertTrue(r in self.stream.getvalue())
     self.assertTrue('&amp;' in self.stream.getvalue())
     self.assertTrue('&lt;' in self.stream.getvalue())
     self.assertTrue('&gt;' in self.stream.getvalue())
     self.assertFalse('&nbsp;' in self.stream.getvalue())
     self.assertFalse('<' in self.stream.getvalue())
     self.assertFalse('>' in self.stream.getvalue())
예제 #45
0
    def setUp(self):
        self._destination = StringIO()
        self._test_results = GreenTestResult(default_args,
                                             GreenStream(StringIO()))
        self._adapter = JUnitXML()

        self._test = ProtoTest()
        self._test.module      = "my_module"
        self._test.class_name  = "MyClass"
        self._test.method_name = "my_method"
예제 #46
0
 def test_printErrorsZHTML(self):
     """
     printErrors() looks correct in html mode
     """
     try:
         raise Exception
     except:
         err = sys.exc_info()
     gtr = GreenTestResult(GreenStream(self.stream), None, 4)
     gtr.colors.html = True
     test = MagicMock()
     gtr.addError(test, proto_error(err))
     gtr.printErrors()
     self.assertIn('\n\n', self.stream.getvalue())
     self.assertIn('(most recent call last)', self.stream.getvalue())
     self.assertIn('test_printErrorsZHTML', self.stream.getvalue())
     self.assertIn('raise Exception', self.stream.getvalue())
     self.assertIn('Error', self.stream.getvalue())
     self.assertIn('<span', self.stream.getvalue())
     self.assertIn('color: rgb(', self.stream.getvalue())
예제 #47
0
 def test_printErrorsStdout(self):
     """
     printErrors() prints out the captured stdout.
     """
     self.args.verbose = 1
     self.args.termcolor = False
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     pt = MyProtoTest()
     output = 'this is what the test spit out to stdout'
     gtr.recordStdout(pt, output)
     gtr.addSuccess(pt)
     gtr.printErrors()
     self.assertIn(output, self.stream.getvalue())
예제 #48
0
    def test_reportOutcomeVerbose(self, mock_proto_test):
        """
        _reportOutcome contains output we expect in verbose mode.
        """
        mockProtoTest = MagicMock()
        mockProtoTest.getDescription.return_value = "a description"
        mock_proto_test.return_value = mockProtoTest
        self.args.verbose = 2

        def isatty():
            return True

        gs = GreenStream(self.stream)
        gs.isatty = isatty
        gtr = GreenTestResult(self.args, gs)
        r = "a fake reason"
        t = MagicMock()
        t.__str__.return_value = "junk"
        gtr._reportOutcome(t, ".", lambda x: x, None, r)
        self.assertIn(r, self.stream.getvalue())
예제 #49
0
    def test_reportOutcomeCursorUp(self, mock_proto_test):
        """
        _reportOutcome moves the cursor up when it needs to.
        """
        mockProtoTest = MagicMock()
        mockProtoTest.getDescription.return_value = "a description"
        mock_proto_test.return_value = mockProtoTest
        self.args.verbose = 2

        def isatty():
            return True

        gs = GreenStream(self.stream)
        gs.isatty = isatty
        gtr = GreenTestResult(self.args, gs)
        r = "a fake reason"
        t = MagicMock()
        t.__str__.return_value = "x" * 1000
        gtr._reportOutcome(t, ".", lambda x: x, None, r)
        self.assertIn(r, self.stream.getvalue())
        self.assertLess(len(self.stream.getvalue()), 2000)
예제 #50
0
 def test_printErrorsStderrQuietStdoutOnSuccess(self):
     """
     printErrors() prints out the captured stdout
     except when quiet_stdout is set to True
     for successful tests.
     """
     self.args.quiet_stdout = True
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     pt = MyProtoTest()
     output = 'this is what the test should not spit out to stdout'
     gtr.recordStderr(pt, output)
     gtr.addSuccess(pt)
     gtr.printErrors()
     self.assertNotIn(output, self.stream.getvalue())
예제 #51
0
    def test_stopTestRun_processes_message(self):
        """
        StopTestRun adds number of processes used to summary
        """
        self.args.processes = 4
        gtr = GreenTestResult(self.args, GreenStream(self.stream))
        gtr.startTestRun()
        gtr.stopTestRun()

        self.assertIn("using 4 processes\n", self.stream.getvalue())
예제 #52
0
    def test_stopTestRun_singular_process_message(self):
        """
        StopTestRun adds correct summary when one process is used
        """
        self.args.processes = 1
        gtr = GreenTestResult(self.args, GreenStream(self.stream))
        gtr.startTestRun()
        gtr.stopTestRun()

        self.assertIn("using 1 process\n", self.stream.getvalue())
예제 #53
0
 def test_printErrorsSkipreport(self):
     """
     printErrors() prints the skip report.
     """
     self.args.verbose = 1
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     pt = MyProtoTest()
     reason = "dog ate homework"
     gtr.addSkip(pt, reason)
     gtr.printErrors()
     self.assertIn(reason, self.stream.getvalue())
예제 #54
0
 def test_printErrorsStdoutQuietStdoutOnError(self):
     """
     printErrors() prints out the captured stdout
     except when quiet_stdout is set to True
     for successful tests, but here we are on a
     failing test.
     """
     self.args.quiet_stdout = True
     try:
         raise Exception
     except:
         err = sys.exc_info()
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     pt = MyProtoTest()
     output = 'this is what the test should spit out to stdout'
     gtr.recordStdout(pt, output)
     gtr.addError(pt, proto_error(err))
     gtr.printErrors()
     self.assertIn(output, self.stream.getvalue())
예제 #55
0
 def test_printErrorsNoTracebacks(self):
     """
     printErrors() omits tracebacks for failures and errors when
     no_tracebacks is True
     """
     self.args.no_tracebacks = True
     try:
         raise Exception
     except:
         err = sys.exc_info()
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     pt = MyProtoTest()
     gtr.addError(pt, proto_error(err))
     gtr.printErrors()
     self.assertNotIn("Exception", self.stream.getvalue())
예제 #56
0
 def test_printErrors_Py2Unicode(self):
     """
     printErrors() doesn't crash in Python 2 when tracebacks contain unicode
     """
     try:
         raise Exception(u'Das Böse ist immer und überall')
     except:
         err = sys.exc_info()
     self.args.verbose = 1
     self.args.termcolor = False
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     gtr.addError(MyProtoTest(), proto_error(err))
     gtr.printErrors() # We shouldn't hit an exception here
     self.assertIn('\n\n', self.stream.getvalue())
     self.assertIn('my_module.MyClass.myMethod', self.stream.getvalue())
     self.assertIn('raise Exception', self.stream.getvalue())
     self.assertIn('Error', self.stream.getvalue())
     self.assertIn('Böse', self.stream.getvalue())
예제 #57
0
 def test_printErrorsVerbose3(self):
     """
     printErrors() looks correct in verbose=3 mode.
     """
     try:
         raise Exception
     except:
         err = sys.exc_info()
     self.args.verbose = 3
     self.args.termcolor = False
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     gtr.addError(MyProtoTest(), proto_error(err))
     gtr.printErrors()
     self.assertIn('\n\n', self.stream.getvalue())
     self.assertIn('my_module.MyClass.myMethod', self.stream.getvalue())
     self.assertIn('test_printErrorsVerbose3', self.stream.getvalue())
     self.assertIn('raise Exception', self.stream.getvalue())
     self.assertIn('Error', self.stream.getvalue())
예제 #58
0
 def test_printErrorsDots(self):
     """
     printErrors() looks correct in verbose=1 (dots) mode.
     """
     try:
         raise Exception
     except:
         err = sys.exc_info()
     self.args.verbose = 1
     self.args.termcolor = False
     gtr = GreenTestResult(self.args, GreenStream(self.stream))
     gtr.addError(MyProtoTest(), proto_error(err))
     gtr.printErrors()
     self.assertIn("\n\n", self.stream.getvalue())
     self.assertIn("my_module.MyClass.myMethod", self.stream.getvalue())
     self.assertIn("test_printErrorsDots", self.stream.getvalue())
     self.assertIn("raise Exception", self.stream.getvalue())
     self.assertIn("Error", self.stream.getvalue())