tests/test-wireproto-serverreactor.py

transaction: tests we don't overwrite branch changes on abort

We actually do not! Great.

…Why are doing a backup of the `branch` files at transaction creation then‽

import unittest

from mercurial import (
    ui as uimod,
    util,
    wireprotoframing as framing,
)
from mercurial.utils import cborutil

ffs = framing.makeframefromhumanstring

OK = b''.join(cborutil.streamencode({b'status': b'ok'}))


def makereactor(deferoutput=False):
    ui = uimod.ui()
    return framing.serverreactor(ui, deferoutput=deferoutput)


def sendframes(reactor, gen):
    """Send a generator of frame bytearray to a reactor.

    Emits a generator of results from ``onframerecv()`` calls.
    """
    for frame in gen:
        header = framing.parseheader(frame)
        payload = frame[framing.FRAME_HEADER_SIZE :]
        assert len(payload) == header.length

        yield reactor.onframerecv(
            framing.frame(
                header.requestid,
                header.streamid,
                header.streamflags,
                header.typeid,
                header.flags,
                payload,
            )
        )


def sendcommandframes(reactor, stream, rid, cmd, args, datafh=None):
    """Generate frames to run a command and send them to a reactor."""
    return sendframes(
        reactor, framing.createcommandframes(stream, rid, cmd, args, datafh)
    )


class ServerReactorTests(unittest.TestCase):
    def _sendsingleframe(self, reactor, f):
        results = list(sendframes(reactor, [f]))
        self.assertEqual(len(results), 1)

        return results[0]

    def assertaction(self, res, expected):
        self.assertIsInstance(res, tuple)
        self.assertEqual(len(res), 2)
        self.assertIsInstance(res[1], dict)
        self.assertEqual(res[0], expected)

    def assertframesequal(self, frames, framestrings):
        expected = [ffs(s) for s in framestrings]
        self.assertEqual(list(frames), expected)

    def test1framecommand(self):
        """Receiving a command in a single frame yields request to run it."""
        reactor = makereactor()
        stream = framing.stream(1)
        results = list(sendcommandframes(reactor, stream, 1, b'mycommand', {}))
        self.assertEqual(len(results), 1)
        self.assertaction(results[0], b'runcommand')
        self.assertEqual(
            results[0][1],
            {
                b'requestid': 1,
                b'command': b'mycommand',
                b'args': {},
                b'redirect': None,
                b'data': None,
            },
        )

        result = reactor.oninputeof()
        self.assertaction(result, b'noop')

    def test1argument(self):
        reactor = makereactor()
        stream = framing.stream(1)
        results = list(
            sendcommandframes(
                reactor, stream, 41, b'mycommand', {b'foo': b'bar'}
            )
        )
        self.assertEqual(len(results), 1)
        self.assertaction(results[0], b'runcommand')
        self.assertEqual(
            results[0][1],
            {
                b'requestid': 41,
                b'command': b'mycommand',
                b'args': {b'foo': b'bar'},
                b'redirect': None,
                b'data': None,
            },
        )

    def testmultiarguments(self):
        reactor = makereactor()
        stream = framing.stream(1)
        results = list(
            sendcommandframes(
                reactor,
                stream,
                1,
                b'mycommand',
                {b'foo': b'bar', b'biz': b'baz'},
            )
        )
        self.assertEqual(len(results), 1)
        self.assertaction(results[0], b'runcommand')
        self.assertEqual(
            results[0][1],
            {
                b'requestid': 1,
                b'command': b'mycommand',
                b'args': {b'foo': b'bar', b'biz': b'baz'},
                b'redirect': None,
                b'data': None,
            },
        )

    def testsimplecommanddata(self):
        reactor = makereactor()
        stream = framing.stream(1)
        results = list(
            sendcommandframes(
                reactor, stream, 1, b'mycommand', {}, util.bytesio(b'data!')
            )
        )
        self.assertEqual(len(results), 2)
        self.assertaction(results[0], b'wantframe')
        self.assertaction(results[1], b'runcommand')
        self.assertEqual(
            results[1][1],
            {
                b'requestid': 1,
                b'command': b'mycommand',
                b'args': {},
                b'redirect': None,
                b'data': b'data!',
            },
        )

    def testmultipledataframes(self):
        frames = [
            ffs(
                b'1 1 stream-begin command-request new|have-data '
                b"cbor:{b'name': b'mycommand'}"
            ),
            ffs(b'1 1 0 command-data continuation data1'),
            ffs(b'1 1 0 command-data continuation data2'),
            ffs(b'1 1 0 command-data eos data3'),
        ]

        reactor = makereactor()
        results = list(sendframes(reactor, frames))
        self.assertEqual(len(results), 4)
        for i in range(3):
            self.assertaction(results[i], b'wantframe')
        self.assertaction(results[3], b'runcommand')
        self.assertEqual(
            results[3][1],
            {
                b'requestid': 1,
                b'command': b'mycommand',
                b'args': {},
                b'redirect': None,
                b'data': b'data1data2data3',
            },
        )

    def testargumentanddata(self):
        frames = [
            ffs(
                b'1 1 stream-begin command-request new|have-data '
                b"cbor:{b'name': b'command', b'args': {b'key': b'val',"
                b"b'foo': b'bar'}}"
            ),
            ffs(b'1 1 0 command-data continuation value1'),
            ffs(b'1 1 0 command-data eos value2'),
        ]

        reactor = makereactor()
        results = list(sendframes(reactor, frames))

        self.assertaction(results[-1], b'runcommand')
        self.assertEqual(
            results[-1][1],
            {
                b'requestid': 1,
                b'command': b'command',
                b'args': {
                    b'key': b'val',
                    b'foo': b'bar',
                },
                b'redirect': None,
                b'data': b'value1value2',
            },
        )

    def testnewandcontinuation(self):
        result = self._sendsingleframe(
            makereactor(),
            ffs(b'1 1 stream-begin command-request new|continuation '),
        )
        self.assertaction(result, b'error')
        self.assertEqual(
            result[1],
            {
                b'message': b'received command request frame with both new and '
                b'continuation flags set',
            },
        )

    def testneithernewnorcontinuation(self):
        result = self._sendsingleframe(
            makereactor(), ffs(b'1 1 stream-begin command-request 0 ')
        )
        self.assertaction(result, b'error')
        self.assertEqual(
            result[1],
            {
                b'message': b'received command request frame with neither new nor '
                b'continuation flags set',
            },
        )

    def testunexpectedcommanddata(self):
        """Command data frame when not running a command is an error."""
        result = self._sendsingleframe(
            makereactor(), ffs(b'1 1 stream-begin command-data 0 ignored')
        )
        self.assertaction(result, b'error')
        self.assertEqual(
            result[1],
            {
                b'message': b'expected sender protocol settings or command request '
                b'frame; got 2',
            },
        )

    def testunexpectedcommanddatareceiving(self):
        """Same as above except the command is receiving."""
        results = list(
            sendframes(
                makereactor(),
                [
                    ffs(
                        b'1 1 stream-begin command-request new|more '
                        b"cbor:{b'name': b'ignored'}"
                    ),
                    ffs(b'1 1 0 command-data eos ignored'),
                ],
            )
        )

        self.assertaction(results[0], b'wantframe')
        self.assertaction(results[1], b'error')
        self.assertEqual(
            results[1][1],
            {
                b'message': b'received command data frame for request that is not '
                b'expecting data: 1',
            },
        )

    def testconflictingrequestidallowed(self):
        """Multiple fully serviced commands with same request ID is allowed."""
        reactor = makereactor()
        results = []
        outstream = reactor.makeoutputstream()
        results.append(
            self._sendsingleframe(
                reactor,
                ffs(
                    b'1 1 stream-begin command-request new '
                    b"cbor:{b'name': b'command'}"
                ),
            )
        )
        result = reactor.oncommandresponsereadyobjects(
            outstream, 1, [b'response1']
        )
        self.assertaction(result, b'sendframes')
        list(result[1][b'framegen'])
        results.append(
            self._sendsingleframe(
                reactor,
                ffs(
                    b'1 1 stream-begin command-request new '
                    b"cbor:{b'name': b'command'}"
                ),
            )
        )
        result = reactor.oncommandresponsereadyobjects(
            outstream, 1, [b'response2']
        )
        self.assertaction(result, b'sendframes')
        list(result[1][b'framegen'])
        results.append(
            self._sendsingleframe(
                reactor,
                ffs(
                    b'1 1 stream-begin command-request new '
                    b"cbor:{b'name': b'command'}"
                ),
            )
        )
        result = reactor.oncommandresponsereadyobjects(
            outstream, 1, [b'response3']
        )
        self.assertaction(result, b'sendframes')
        list(result[1][b'framegen'])

        for i in range(3):
            self.assertaction(results[i], b'runcommand')
            self.assertEqual(
                results[i][1],
                {
                    b'requestid': 1,
                    b'command': b'command',
                    b'args': {},
                    b'redirect': None,
                    b'data': None,
                },
            )

    def testconflictingrequestid(self):
        """Request ID for new command matching in-flight command is illegal."""
        results = list(
            sendframes(
                makereactor(),
                [
                    ffs(
                        b'1 1 stream-begin command-request new|more '
                        b"cbor:{b'name': b'command'}"
                    ),
                    ffs(
                        b'1 1 0 command-request new '
                        b"cbor:{b'name': b'command1'}"
                    ),
                ],
            )
        )

        self.assertaction(results[0], b'wantframe')
        self.assertaction(results[1], b'error')
        self.assertEqual(
            results[1][1],
            {
                b'message': b'request with ID 1 already received',
            },
        )

    def testinterleavedcommands(self):
        cbor1 = b''.join(
            cborutil.streamencode(
                {
                    b'name': b'command1',
                    b'args': {
                        b'foo': b'bar',
                        b'key1': b'val',
                    },
                }
            )
        )
        cbor3 = b''.join(
            cborutil.streamencode(
                {
                    b'name': b'command3',
                    b'args': {
                        b'biz': b'baz',
                        b'key': b'val',
                    },
                }
            )
        )

        results = list(
            sendframes(
                makereactor(),
                [
                    ffs(
                        b'1 1 stream-begin command-request new|more %s'
                        % cbor1[0:6]
                    ),
                    ffs(b'3 1 0 command-request new|more %s' % cbor3[0:10]),
                    ffs(
                        b'1 1 0 command-request continuation|more %s'
                        % cbor1[6:9]
                    ),
                    ffs(
                        b'3 1 0 command-request continuation|more %s'
                        % cbor3[10:13]
                    ),
                    ffs(b'3 1 0 command-request continuation %s' % cbor3[13:]),
                    ffs(b'1 1 0 command-request continuation %s' % cbor1[9:]),
                ],
            )
        )

        self.assertEqual(
            [t[0] for t in results],
            [
                b'wantframe',
                b'wantframe',
                b'wantframe',
                b'wantframe',
                b'runcommand',
                b'runcommand',
            ],
        )

        self.assertEqual(
            results[4][1],
            {
                b'requestid': 3,
                b'command': b'command3',
                b'args': {b'biz': b'baz', b'key': b'val'},
                b'redirect': None,
                b'data': None,
            },
        )
        self.assertEqual(
            results[5][1],
            {
                b'requestid': 1,
                b'command': b'command1',
                b'args': {b'foo': b'bar', b'key1': b'val'},
                b'redirect': None,
                b'data': None,
            },
        )

    def testmissingcommanddataframe(self):
        # The reactor doesn't currently handle partially received commands.
        # So this test is failing to do anything with request 1.
        frames = [
            ffs(
                b'1 1 stream-begin command-request new|have-data '
                b"cbor:{b'name': b'command1'}"
            ),
            ffs(b'3 1 0 command-request new ' b"cbor:{b'name': b'command2'}"),
        ]
        results = list(sendframes(makereactor(), frames))
        self.assertEqual(len(results), 2)
        self.assertaction(results[0], b'wantframe')
        self.assertaction(results[1], b'runcommand')

    def testmissingcommanddataframeflags(self):
        frames = [
            ffs(
                b'1 1 stream-begin command-request new|have-data '
                b"cbor:{b'name': b'command1'}"
            ),
            ffs(b'1 1 0 command-data 0 data'),
        ]
        results = list(sendframes(makereactor(), frames))
        self.assertEqual(len(results), 2)
        self.assertaction(results[0], b'wantframe')
        self.assertaction(results[1], b'error')
        self.assertEqual(
            results[1][1],
            {
                b'message': b'command data frame without flags',
            },
        )

    def testframefornonreceivingrequest(self):
        """Receiving a frame for a command that is not receiving is illegal."""
        results = list(
            sendframes(
                makereactor(),
                [
                    ffs(
                        b'1 1 stream-begin command-request new '
                        b"cbor:{b'name': b'command1'}"
                    ),
                    ffs(
                        b'3 1 0 command-request new|have-data '
                        b"cbor:{b'name': b'command3'}"
                    ),
                    ffs(b'5 1 0 command-data eos ignored'),
                ],
            )
        )
        self.assertaction(results[2], b'error')
        self.assertEqual(
            results[2][1],
            {
                b'message': b'received frame for request that is not receiving: 5',
            },
        )

    def testsimpleresponse(self):
        """Bytes response to command sends result frames."""
        reactor = makereactor()
        instream = framing.stream(1)
        list(sendcommandframes(reactor, instream, 1, b'mycommand', {}))

        outstream = reactor.makeoutputstream()
        result = reactor.oncommandresponsereadyobjects(
            outstream, 1, [b'response']
        )
        self.assertaction(result, b'sendframes')
        self.assertframesequal(
            result[1][b'framegen'],
            [
                b'1 2 stream-begin stream-settings eos cbor:b"identity"',
                b'1 2 encoded command-response continuation %s' % OK,
                b'1 2 encoded command-response continuation cbor:b"response"',
                b'1 2 0 command-response eos ',
            ],
        )

    def testmultiframeresponse(self):
        """Bytes response spanning multiple frames is handled."""
        first = b'x' * framing.DEFAULT_MAX_FRAME_SIZE
        second = b'y' * 100

        reactor = makereactor()
        instream = framing.stream(1)
        list(sendcommandframes(reactor, instream, 1, b'mycommand', {}))

        outstream = reactor.makeoutputstream()
        result = reactor.oncommandresponsereadyobjects(
            outstream, 1, [first + second]
        )
        self.assertaction(result, b'sendframes')
        self.assertframesequal(
            result[1][b'framegen'],
            [
                b'1 2 stream-begin stream-settings eos cbor:b"identity"',
                b'1 2 encoded command-response continuation %s' % OK,
                b'1 2 encoded command-response continuation Y\x80d',
                b'1 2 encoded command-response continuation %s' % first,
                b'1 2 encoded command-response continuation %s' % second,
                b'1 2 0 command-response eos ',
            ],
        )

    def testservererror(self):
        reactor = makereactor()
        instream = framing.stream(1)
        list(sendcommandframes(reactor, instream, 1, b'mycommand', {}))

        outstream = reactor.makeoutputstream()
        result = reactor.onservererror(outstream, 1, b'some message')
        self.assertaction(result, b'sendframes')
        self.assertframesequal(
            result[1][b'framegen'],
            [
                b"1 2 stream-begin error-response 0 "
                b"cbor:{b'type': b'server', "
                b"b'message': [{b'msg': b'some message'}]}",
            ],
        )

    def test1commanddeferresponse(self):
        """Responses when in deferred output mode are delayed until EOF."""
        reactor = makereactor(deferoutput=True)
        instream = framing.stream(1)
        results = list(
            sendcommandframes(reactor, instream, 1, b'mycommand', {})
        )
        self.assertEqual(len(results), 1)
        self.assertaction(results[0], b'runcommand')

        outstream = reactor.makeoutputstream()
        result = reactor.oncommandresponsereadyobjects(
            outstream, 1, [b'response']
        )
        self.assertaction(result, b'noop')
        result = reactor.oninputeof()
        self.assertaction(result, b'sendframes')
        self.assertframesequal(
            result[1][b'framegen'],
            [
                b'1 2 stream-begin stream-settings eos cbor:b"identity"',
                b'1 2 encoded command-response continuation %s' % OK,
                b'1 2 encoded command-response continuation cbor:b"response"',
                b'1 2 0 command-response eos ',
            ],
        )

    def testmultiplecommanddeferresponse(self):
        reactor = makereactor(deferoutput=True)
        instream = framing.stream(1)
        list(sendcommandframes(reactor, instream, 1, b'command1', {}))
        list(sendcommandframes(reactor, instream, 3, b'command2', {}))

        outstream = reactor.makeoutputstream()
        result = reactor.oncommandresponsereadyobjects(
            outstream, 1, [b'response1']
        )
        self.assertaction(result, b'noop')
        result = reactor.oncommandresponsereadyobjects(
            outstream, 3, [b'response2']
        )
        self.assertaction(result, b'noop')
        result = reactor.oninputeof()
        self.assertaction(result, b'sendframes')
        self.assertframesequal(
            result[1][b'framegen'],
            [
                b'1 2 stream-begin stream-settings eos cbor:b"identity"',
                b'1 2 encoded command-response continuation %s' % OK,
                b'1 2 encoded command-response continuation cbor:b"response1"',
                b'1 2 0 command-response eos ',
                b'3 2 encoded command-response continuation %s' % OK,
                b'3 2 encoded command-response continuation cbor:b"response2"',
                b'3 2 0 command-response eos ',
            ],
        )

    def testrequestidtracking(self):
        reactor = makereactor(deferoutput=True)
        instream = framing.stream(1)
        list(sendcommandframes(reactor, instream, 1, b'command1', {}))
        list(sendcommandframes(reactor, instream, 3, b'command2', {}))
        list(sendcommandframes(reactor, instream, 5, b'command3', {}))

        # Register results for commands out of order.
        outstream = reactor.makeoutputstream()
        reactor.oncommandresponsereadyobjects(outstream, 3, [b'response3'])
        reactor.oncommandresponsereadyobjects(outstream, 1, [b'response1'])
        reactor.oncommandresponsereadyobjects(outstream, 5, [b'response5'])

        result = reactor.oninputeof()
        self.assertaction(result, b'sendframes')
        self.assertframesequal(
            result[1][b'framegen'],
            [
                b'3 2 stream-begin stream-settings eos cbor:b"identity"',
                b'3 2 encoded command-response continuation %s' % OK,
                b'3 2 encoded command-response continuation cbor:b"response3"',
                b'3 2 0 command-response eos ',
                b'1 2 encoded command-response continuation %s' % OK,
                b'1 2 encoded command-response continuation cbor:b"response1"',
                b'1 2 0 command-response eos ',
                b'5 2 encoded command-response continuation %s' % OK,
                b'5 2 encoded command-response continuation cbor:b"response5"',
                b'5 2 0 command-response eos ',
            ],
        )

    def testduplicaterequestonactivecommand(self):
        """Receiving a request ID that matches a request that isn't finished."""
        reactor = makereactor()
        stream = framing.stream(1)
        list(sendcommandframes(reactor, stream, 1, b'command1', {}))
        results = list(sendcommandframes(reactor, stream, 1, b'command1', {}))

        self.assertaction(results[0], b'error')
        self.assertEqual(
            results[0][1],
            {
                b'message': b'request with ID 1 is already active',
            },
        )

    def testduplicaterequestonactivecommandnosend(self):
        """Same as above but we've registered a response but haven't sent it."""
        reactor = makereactor()
        instream = framing.stream(1)
        list(sendcommandframes(reactor, instream, 1, b'command1', {}))
        outstream = reactor.makeoutputstream()
        reactor.oncommandresponsereadyobjects(outstream, 1, [b'response'])

        # We've registered the response but haven't sent it. From the
        # perspective of the reactor, the command is still active.

        results = list(sendcommandframes(reactor, instream, 1, b'command1', {}))
        self.assertaction(results[0], b'error')
        self.assertEqual(
            results[0][1],
            {
                b'message': b'request with ID 1 is already active',
            },
        )

    def testduplicaterequestaftersend(self):
        """We can use a duplicate request ID after we've sent the response."""
        reactor = makereactor()
        instream = framing.stream(1)
        list(sendcommandframes(reactor, instream, 1, b'command1', {}))
        outstream = reactor.makeoutputstream()
        res = reactor.oncommandresponsereadyobjects(outstream, 1, [b'response'])
        list(res[1][b'framegen'])

        results = list(sendcommandframes(reactor, instream, 1, b'command1', {}))
        self.assertaction(results[0], b'runcommand')

    def testprotocolsettingsnoflags(self):
        result = self._sendsingleframe(
            makereactor(), ffs(b'0 1 stream-begin sender-protocol-settings 0 ')
        )
        self.assertaction(result, b'error')
        self.assertEqual(
            result[1],
            {
                b'message': b'sender protocol settings frame must have '
                b'continuation or end of stream flag set',
            },
        )

    def testprotocolsettingsconflictflags(self):
        result = self._sendsingleframe(
            makereactor(),
            ffs(b'0 1 stream-begin sender-protocol-settings continuation|eos '),
        )
        self.assertaction(result, b'error')
        self.assertEqual(
            result[1],
            {
                b'message': b'sender protocol settings frame cannot have both '
                b'continuation and end of stream flags set',
            },
        )

    def testprotocolsettingsemptypayload(self):
        result = self._sendsingleframe(
            makereactor(),
            ffs(b'0 1 stream-begin sender-protocol-settings eos '),
        )
        self.assertaction(result, b'error')
        self.assertEqual(
            result[1],
            {
                b'message': b'sender protocol settings frame did not contain CBOR '
                b'data',
            },
        )

    def testprotocolsettingsmultipleobjects(self):
        result = self._sendsingleframe(
            makereactor(),
            ffs(
                b'0 1 stream-begin sender-protocol-settings eos '
                b'\x46foobar\x43foo'
            ),
        )
        self.assertaction(result, b'error')
        self.assertEqual(
            result[1],
            {
                b'message': b'sender protocol settings frame contained multiple '
                b'CBOR values',
            },
        )

    def testprotocolsettingscontentencodings(self):
        reactor = makereactor()

        result = self._sendsingleframe(
            reactor,
            ffs(
                b'0 1 stream-begin sender-protocol-settings eos '
                b'cbor:{b"contentencodings": [b"a", b"b"]}'
            ),
        )
        self.assertaction(result, b'wantframe')

        self.assertEqual(reactor._state, b'idle')
        self.assertEqual(
            reactor._sendersettings[b'contentencodings'], [b'a', b'b']
        )

    def testprotocolsettingsmultipleframes(self):
        reactor = makereactor()

        data = b''.join(
            cborutil.streamencode(
                {
                    b'contentencodings': [b'value1', b'value2'],
                }
            )
        )

        results = list(
            sendframes(
                reactor,
                [
                    ffs(
                        b'0 1 stream-begin sender-protocol-settings continuation %s'
                        % data[0:5]
                    ),
                    ffs(b'0 1 0 sender-protocol-settings eos %s' % data[5:]),
                ],
            )
        )

        self.assertEqual(len(results), 2)

        self.assertaction(results[0], b'wantframe')
        self.assertaction(results[1], b'wantframe')

        self.assertEqual(reactor._state, b'idle')
        self.assertEqual(
            reactor._sendersettings[b'contentencodings'], [b'value1', b'value2']
        )

    def testprotocolsettingsbadcbor(self):
        result = self._sendsingleframe(
            makereactor(),
            ffs(b'0 1 stream-begin sender-protocol-settings eos badvalue'),
        )
        self.assertaction(result, b'error')

    def testprotocolsettingsnoninitial(self):
        # Cannot have protocol settings frames as non-initial frames.
        reactor = makereactor()

        stream = framing.stream(1)
        results = list(sendcommandframes(reactor, stream, 1, b'mycommand', {}))
        self.assertEqual(len(results), 1)
        self.assertaction(results[0], b'runcommand')

        result = self._sendsingleframe(
            reactor, ffs(b'0 1 0 sender-protocol-settings eos ')
        )
        self.assertaction(result, b'error')
        self.assertEqual(
            result[1],
            {
                b'message': b'expected command request frame; got 8',
            },
        )


if __name__ == '__main__':
    import silenttestrunner

    silenttestrunner.main(__name__)