def test_non_subunit_disabled_raises(self):
     source = BytesIO(b"foo\nbar\n")
     result = doubles.StreamResult()
     case = v2.ByteStreamToStreamResult(source)
     e = self.assertRaises(Exception, case.run, result)  # noqa
     self.assertEqual(b'f', e.args[1])
     self.assertEqual(b'oo\nbar\n', source.read())
     self.assertEqual([], result._events)
 def test_trivial_enumeration(self):
     source = BytesIO(CONSTANT_ENUM)
     result = doubles.StreamResult()
     v2.ByteStreamToStreamResult(source,
                                 non_subunit_name="stdout").run(result)
     self.assertEqual(b'', source.read())
     self.assertEqual([
         ('status', 'foo', 'exists', None, True, None, None, False, None,
          None, None),
     ], result._events)
 def check_events(self, source_bytes, events):
     source = BytesIO(source_bytes)
     result = doubles.StreamResult()
     v2.ByteStreamToStreamResult(source,
                                 non_subunit_name="stdout").run(result)
     self.assertEqual(b'', source.read())
     self.assertEqual(events, result._events)
     # any file attachments should be byte contents [as users assume that].
     for event in result._events:
         if event[5] is not None:
             self.assertIsInstance(event[6], bytes)
Example #4
0
 def test_includes_timing_output(self):
     bytestream = io.BytesIO()
     runner = run.SubunitTestRunner(stream=bytestream)
     test = testtools.PlaceHolder('name')
     runner.run(test)
     bytestream.seek(0)
     eventstream = StreamResult()
     v2.ByteStreamToStreamResult(bytestream).run(eventstream)
     timestamps = [
         event[-1] for event in eventstream._events if event is not None
     ]
     self.assertNotEqual([], timestamps)
 def test_default(self):
     byte_stream = compat.BytesIO()
     stream = v2.StreamResultToBytes(byte_stream)
     stream.status(test_id="foo", test_status="inprogress")
     stream.status(test_id="foo", test_status="skip")
     output = self.run_command([], byte_stream.getvalue())
     events = doubles.StreamResult()
     v2.ByteStreamToStreamResult(compat.BytesIO(output)).run(events)
     self.assertEqual([
         ('status', 'foo', 'inprogress'),
         ('status', 'foo', 'skip'),
     ], [event[:3] for event in events._events])
Example #6
0
 def test_enumerates_tests_before_run(self):
     bytestream = io.BytesIO()
     runner = run.SubunitTestRunner(stream=bytestream)
     test1 = testtools.PlaceHolder('name1')
     test2 = testtools.PlaceHolder('name2')
     case = unittest.TestSuite([test1, test2])
     runner.run(case)
     bytestream.seek(0)
     eventstream = StreamResult()
     v2.ByteStreamToStreamResult(bytestream).run(eventstream)
     self.assertEqual([
         ('status', 'name1', 'exists'),
         ('status', 'name2', 'exists'),
     ], [event[:3] for event in eventstream._events[:2]])
 def test_signature_middle_utf8_char(self):
     utf8_bytes = b'\xe3\xb3\x8a'
     source = BytesIO(utf8_bytes)
     # Should be treated as one character (it is u'\u3cca') and wrapped
     result = doubles.StreamResult()
     v2.ByteStreamToStreamResult(source,
                                 non_subunit_name="stdout").run(result)
     self.assertEqual([
         ('status', None, None, None, True, 'stdout', b'\xe3', False, None,
          None, None),
         ('status', None, None, None, True, 'stdout', b'\xb3', False, None,
          None, None),
         ('status', None, None, None, True, 'stdout', b'\x8a', False, None,
          None, None),
     ], result._events)
Example #8
0
 def test_todo_and_skip(self):
     # A file
     # not ok 1 - a fail
     # not ok 2 - another fail # SKIP instead
     # results in two tests, numbered and commented.
     self.tap.write(compat._u("not ok 1 - a fail but # TODO but is TODO\n"))
     self.tap.write(compat._u("not ok 2 - another fail # SKIP instead\n"))
     self.tap.seek(0)
     result = pysubunit.TAP2SubUnit(self.tap, self.subunit)
     self.assertEqual(0, result)
     self.subunit.seek(0)
     events = doubles.StreamResult()
     v2.ByteStreamToStreamResult(self.subunit).run(events)
     self.check_events([('status', 'test 1 - a fail but', 'xfail', None,
                         False, 'tap comment', b'but is TODO', True,
                         'text/plain; charset=UTF8', None, None),
                        ('status', 'test 2 - another fail', 'skip', None,
                         False, 'tap comment', b'instead', True,
                         'text/plain; charset=UTF8', None, None)])
Example #9
0
def tag_stream(original, filtered, tags):
    """Alter tags on a stream.

    :param original: The input stream.
    :param filtered: The output stream.
    :param tags: The tags to apply. As in a normal stream - a list of 'TAG' or
        '-TAG' commands.

        A 'TAG' command will add the tag to the output stream,
        and override any existing '-TAG' command in that stream.
        Specifically:
         * A global 'tags: TAG' will be added to the start of the stream.
         * Any tags commands with -TAG will have the -TAG removed.

        A '-TAG' command will remove the TAG command from the stream.
        Specifically:
         * A 'tags: -TAG' command will be added to the start of the stream.
         * Any 'tags: TAG' command will have 'TAG' removed from it.
        Additionally, any redundant tagging commands (adding a tag globally
        present, or removing a tag globally removed) are stripped as a
        by-product of the filtering.
    :return: 0
    """
    new_tags, gone_tags = tags_to_new_gone(tags)
    source = v2.ByteStreamToStreamResult(original, non_subunit_name='stdout')

    class Tagger(testtools.CopyStreamResult):
        def status(self, **kwargs):
            tags = kwargs.get('test_tags')
            if not tags:
                tags = set()
            tags.update(new_tags)
            tags.difference_update(gone_tags)
            if tags:
                kwargs['test_tags'] = tags
            else:
                kwargs['test_tags'] = None
            super(Tagger, self).status(**kwargs)

    output = Tagger([v2.StreamResultToBytes(filtered)])
    source.run(output)
    return 0
 def test_tags(self):
     byte_stream = compat.BytesIO()
     stream = v2.StreamResultToBytes(byte_stream)
     stream.status(test_id="foo",
                   test_status="inprogress",
                   test_tags=set(["a"]))
     stream.status(test_id="foo",
                   test_status="success",
                   test_tags=set(["a"]))
     stream.status(test_id="bar", test_status="inprogress")
     stream.status(test_id="bar", test_status="inprogress")
     stream.status(test_id="baz",
                   test_status="inprogress",
                   test_tags=set(["a"]))
     stream.status(test_id="baz",
                   test_status="success",
                   test_tags=set(["a"]))
     output = self.run_command(['-s', '--with-tag', 'a'],
                               byte_stream.getvalue())
     events = doubles.StreamResult()
     v2.ByteStreamToStreamResult(compat.BytesIO(output)).run(events)
     ids = set(event[1] for event in events._events)
     self.assertEqual(set(['foo', 'baz']), ids)
 def test_non_pysubunit_encapsulated(self):
     source = BytesIO(b"foo\nbar\n")
     result = doubles.StreamResult()
     v2.ByteStreamToStreamResult(source,
                                 non_subunit_name="stdout").run(result)
     self.assertEqual([
         ('status', None, None, None, True, 'stdout', b'f', False, None,
          None, None),
         ('status', None, None, None, True, 'stdout', b'o', False, None,
          None, None),
         ('status', None, None, None, True, 'stdout', b'o', False, None,
          None, None),
         ('status', None, None, None, True, 'stdout', b'\n', False, None,
          None, None),
         ('status', None, None, None, True, 'stdout', b'b', False, None,
          None, None),
         ('status', None, None, None, True, 'stdout', b'a', False, None,
          None, None),
         ('status', None, None, None, True, 'stdout', b'r', False, None,
          None, None),
         ('status', None, None, None, True, 'stdout', b'\n', False, None,
          None, None),
     ], result._events)
     self.assertEqual(b'', source.read())
Example #12
0
 def check_events(self, events):
     self.subunit.seek(0)
     eventstream = doubles.StreamResult()
     v2.ByteStreamToStreamResult(self.subunit).run(eventstream)
     self.assertEqual(events, eventstream._events)
Example #13
0
def run_tests_from_stream(input_stream,
                          result,
                          passthrough_stream=None,
                          forward_stream=None,
                          protocol_version=1,
                          passthrough_subunit=True):
    """Run tests from a subunit input stream through 'result'.

    Non-test events - top level file attachments - are expected to be
    dropped by v2 StreamResults at the present time (as all the analysis code
    is in ExtendedTestResult API's), so to implement passthrough_stream they
    are diverted and copied directly when that is set.

    :param input_stream: A stream containing subunit input.
    :param result: A TestResult that will receive the test events.
        NB: This should be an ExtendedTestResult for v1 and a StreamResult for
        v2.
    :param passthrough_stream: All non-subunit input received will be
        sent to this stream.  If not provided, uses the ``TestProtocolServer``
        default, which is ``sys.stdout``.
    :param forward_stream: All subunit input received will be forwarded
        to this stream. If not provided, uses the ``TestProtocolServer``
        default, which is to not forward any input. Do not set this when
        transforming the stream - items would be double-reported.
    :param protocol_version: What version of the subunit protocol to expect.
    :param passthrough_subunit: If True, passthrough should be as subunit
        otherwise unwrap it. Only has effect when forward_stream is None.
        (when forwarding as subunit non-subunit input is always turned into
        subunit)
    """
    if 1 == protocol_version:
        test = pysubunit.ProtocolTestCase(input_stream,
                                          passthrough=passthrough_stream,
                                          forward=forward_stream)
    elif 2 == protocol_version:
        # In all cases we encapsulate unknown inputs.
        if forward_stream is not None:
            # Send events to forward_stream as subunit.
            forward_result = v2.StreamResultToBytes(forward_stream)
            # If we're passing non-subunit through, copy:
            if passthrough_stream is None:
                # Not passing non-test events - split them off to nothing.
                router = testtools.StreamResultRouter(forward_result)
                router.add_rule(testtools.StreamResult(),
                                'test_id',
                                test_id=None)
                result = testtools.CopyStreamResult([router, result])
            else:
                # otherwise, copy all events to forward_result
                result = testtools.CopyStreamResult([forward_result, result])
        elif passthrough_stream is not None:
            # Route non-test events to passthrough_stream, unwrapping them for
            # display.
            if not passthrough_subunit:
                passthrough_result = test_results.CatFiles(passthrough_stream)
            else:
                passthrough_result = v2.StreamResultToBytes(passthrough_stream)
            result = testtools.StreamResultRouter(result)
            result.add_rule(passthrough_result, 'test_id', test_id=None)
        test = v2.ByteStreamToStreamResult(input_stream,
                                           non_subunit_name='stdout')
    else:
        raise Exception("Unknown protocol version.")
    result.startTestRun()
    test.run(result)
    result.stopTestRun()
 def test_hypothesis_decoding(self, code_bytes):
     source = BytesIO(code_bytes)
     result = doubles.StreamResult()
     stream = v2.ByteStreamToStreamResult(source, non_subunit_name="stdout")
     stream.run(result)
     self.assertEqual(b'', source.read())