Python Tracker.add_skip方法代码示例

# 需要导入模块: from tap.tracker import Tracker [as 别名]
# 或者: from tap.tracker.Tracker import add_skip [as 别名]
 def test_adds_skip(self):
     tracker = Tracker()
     tracker.add_skip('FakeTestCase', 'a description', 'a reason')
     line = tracker._test_cases['FakeTestCase'][0]
     self.assertTrue(line.ok)
     self.assertEqual(line.description, 'a description')
     self.assertEqual(line.directive.text, 'SKIP a reason')

# 需要导入模块: from tap.tracker import Tracker [as 别名]
# 或者: from tap.tracker.Tracker import add_skip [as 别名]
 def test_adds_skip(self):
     tracker = Tracker()
     tracker.add_skip('FakeTestCase', 'a description', 'a reason')
     line = tracker._test_cases['FakeTestCase'][0]
     self.assertEqual(line.status, 'ok')
     self.assertEqual(line.description, 'a description')
     self.assertEqual(line.directive, '# SKIP a reason')

# 需要导入模块: from tap.tracker import Tracker [as 别名]
# 或者: from tap.tracker.Tracker import add_skip [as 别名]
    def test_does_not_write_header(self):
        stream = StringIO()
        tracker = Tracker(streaming=True, stream=stream, header=False)

        tracker.add_skip('FakeTestCase', 'YESSS!', 'a reason')

        expected = inspect.cleandoc(
            """ok 1 - YESSS! # SKIP a reason""")
        self.assertEqual(stream.getvalue().strip(), expected)

# 需要导入模块: from tap.tracker import Tracker [as 别名]
# 或者: from tap.tracker.Tracker import add_skip [as 别名]
    def test_add_skip_writes_to_stream_while_streaming(self):
        stream = StringIO()
        tracker = Tracker(streaming=True, stream=stream)

        tracker.add_skip('FakeTestCase', 'YESSS!', 'a reason')

        expected = inspect.cleandoc(
            """# TAP results for FakeTestCase
            ok 1 - YESSS! # SKIP a reason
            """)
        self.assertEqual(stream.getvalue().strip(), expected)

# 需要导入模块: from tap.tracker import Tracker [as 别名]
# 或者: from tap.tracker.Tracker import add_skip [as 别名]
    def test_add_skip_writes_to_stream_while_streaming(self):
        stream = StringIO()
        tracker = Tracker(streaming=True, stream=stream)

        tracker.add_skip('FakeTestCase', 'YESSS!', 'a reason')

        expected = inspect.cleandoc(
            """{header}
            ok 1 - YESSS! # SKIP a reason
            """.format(
                header=self._make_header('FakeTestCase')))
        self.assertEqual(stream.getvalue().strip(), expected)

# 需要导入模块: from tap.tracker import Tracker [as 别名]
# 或者: from tap.tracker.Tracker import add_skip [as 别名]
    def test_streaming_writes_tap_version_13(self):
        stream = StringIO()
        tracker = Tracker(streaming=True, stream=stream)

        tracker.add_skip("FakeTestCase", "YESSS!", "a reason")

        expected = inspect.cleandoc(
            """
            TAP version 13
            {header}
            ok 1 YESSS! # SKIP a reason
            """.format(
                header=self._make_header("FakeTestCase")
            )
        )
        self.assertEqual(stream.getvalue().strip(), expected)

# 需要导入模块: from tap.tracker import Tracker [as 别名]
# 或者: from tap.tracker.Tracker import add_skip [as 别名]
class TAPTestResult(TextTestResult):

    # This attribute will store the user's desired output directory.
    OUTDIR = None

    def __init__(self, stream, descriptions, verbosity):
        super(TAPTestResult, self).__init__(stream, descriptions, verbosity)
        self.tracker = Tracker(outdir=self.OUTDIR)

    def stopTestRun(self):
        """Once the test run is complete, generate each of the TAP files."""
        super(TAPTestResult, self).stopTestRun()
        self.tracker.generate_tap_reports()

    def addError(self, test, err):
        super(TAPTestResult, self).addError(test, err)
        self.tracker.add_not_ok(self._cls_name(test), self._description(test))

    def addFailure(self, test, err):
        super(TAPTestResult, self).addFailure(test, err)
        self.tracker.add_not_ok(self._cls_name(test), self._description(test))

    def addSuccess(self, test):
        super(TAPTestResult, self).addSuccess(test)
        self.tracker.add_ok(self._cls_name(test), self._description(test))

    def addSkip(self, test, reason):
        super(TAPTestResult, self).addSkip(test, reason)
        self.tracker.add_skip(
            self._cls_name(test), self._description(test), reason)

    def addExpectedFailure(self, test, err):
        super(TAPTestResult, self).addExpectedFailure(test, err)
        self.tracker.add_not_ok(self._cls_name(test), self._description(test),
                                '(expected failure)')

    def addUnexpectedSuccess(self, test):
        super(TAPTestResult, self).addUnexpectedSuccess(test)
        self.tracker.add_ok(self._cls_name(test), self._description(test),
                            '(unexpected success)')

    def _cls_name(self, test):
        return test.__class__.__name__

    def _description(self, test):
        return test.shortDescription() or str(test)

# 需要导入模块: from tap.tracker import Tracker [as 别名]
# 或者: from tap.tracker.Tracker import add_skip [as 别名]
class TAP(Plugin):
    """This plugin provides test results in the Test Anything Protocol format.
    """
    name = 'tap'

    def options(self, parser, env=os.environ):
        super(TAP, self).options(parser, env=env)
        parser.add_option(
            '--tap-outdir',
            help='An optional output directory to write TAP files to. If the'
                 ' directory does not exist, it will be created.')

    def configure(self, options, conf):
        super(TAP, self).configure(options, conf)
        if self.enabled:
            self.tracker = Tracker(outdir=options.tap_outdir)

    def finalize(self, results):
        self.tracker.generate_tap_reports()

    def addError(self, test, err):
        err_cls, reason, _ = err
        if err_cls != SkipTest:
            self.tracker.add_not_ok(
                self._cls_name(test), self._description(test))
        else:
            self.tracker.add_skip(
                self._cls_name(test), self._description(test), reason)

    def addFailure(self, test, err):
        self.tracker.add_not_ok(self._cls_name(test), self._description(test))

    def addSuccess(self, test):
        self.tracker.add_ok(self._cls_name(test), self._description(test))

    def _cls_name(self, test):
        # nose masks the true test case name so the real class name is found
        # under the test attribute.
        return test.test.__class__.__name__

    def _description(self, test):
        return test.shortDescription() or str(test)

# 需要导入模块: from tap.tracker import Tracker [as 别名]
# 或者: from tap.tracker.Tracker import add_skip [as 别名]
class TAP(Plugin):
    """This plugin provides test results in the Test Anything Protocol format.
    """
    name = 'tap'

    def options(self, parser, env=os.environ):
        super(TAP, self).options(parser, env=env)
        parser.add_option(
            '--tap-stream', default=False, action='store_true',
            help=_('Stream TAP output instead of the default test runner'
                   ' output.'))
        parser.add_option(
            '--tap-outdir', metavar='PATH', help=_(
                'An optional output directory to write TAP files to. '
                'If the directory does not exist, it will be created.'))
        parser.add_option(
            '--tap-combined', default=False, action='store_true',
            help=_('Store all TAP test results into a combined output file.'))
        parser.add_option(
            '--tap-format', default='', metavar='FORMAT',
            help=_(
                'An optional format string for the TAP output.'
                ' The format options are:'
                ' {short_description} for the short description, and'
                ' {method_name} for the test method name.'))

    def configure(self, options, conf):
        super(TAP, self).configure(options, conf)
        if self.enabled:
            self.tracker = Tracker(
                outdir=options.tap_outdir, combined=options.tap_combined,
                streaming=options.tap_stream)
        self._format = options.tap_format

    def finalize(self, results):
        self.tracker.generate_tap_reports()

    def setOutputStream(self, stream):
        # When streaming is on, hijack the stream and return a dummy to send
        # standard nose output to oblivion.
        if self.tracker.streaming:
            self.tracker.stream = stream
            return DummyStream()
        return stream

    def addError(self, test, err):
        err_cls, reason, _ = err
        if err_cls != SkipTest:
            self.tracker.add_not_ok(
                self._cls_name(test), self._description(test))
        else:
            self.tracker.add_skip(
                self._cls_name(test), self._description(test), reason)

    def addFailure(self, test, err):
        self.tracker.add_not_ok(self._cls_name(test), self._description(test))

    def addSuccess(self, test):
        self.tracker.add_ok(self._cls_name(test), self._description(test))

    def _cls_name(self, test):
        if isinstance(test, ContextSuite):
            # In the class setup and teardown, test is a ContextSuite
            # instead of a test case. Grab the name from the context.
            return test.context.__name__
        else:
            # nose masks the true test case name so the real class name
            # is found under the test attribute.
            return test.test.__class__.__name__

    def _description(self, test):
        if self._format:
            try:
                return self._format.format(
                    method_name=str(test),
                    short_description=test.shortDescription() or '')
            except KeyError:
                sys.exit(_(
                    'Bad format string: {format}\n'
                    'Replacement options are: {{short_description}} and '
                    '{{method_name}}').format(format=self._format))

        return test.shortDescription() or str(test)