view tests/test-wireproto-serverreactor.py @ 44363:f7459da77f23

nodemap: introduce an option to use mmap to read the nodemap mapping

The performance and memory benefit is much greater if we don't have to copy all
the data in memory for each information. So we introduce an option (on by
default) to read the data using mmap.

This changeset is the last one definition the API for index support nodemap
data. (they have to be able to use the mmaping).

Below are some benchmark comparing the best we currently have in 5.3 with the
final step of this series (using the persistent nodemap implementation in
Rust). The benchmark run `hg perfindex` with various revset and the following
variants:

Before:

 * do not use the persistent nodemap
 * use the CPython implementation of the index for nodemap
 * use mmapping of the changelog index

After:

 * use the MixedIndex Rust code, with the NodeTree object for nodemap access
   (still in review)
 * use the persistent nodemap data from disk
 * access the persistent nodemap data through mmap
 * use mmapping of the changelog index

The persistent nodemap greatly speed up  most operation on very large
repositories. Some of the previously very fast lookup end up a bit slower because
the persistent nodemap has to be setup. However the absolute slowdown is very
small and won't matters in the big picture.

Here are some numbers (in seconds) for the reference copy of mozilla-try:

Revset            Before   After     abs-change speedup

-10000:           0.004622 0.005532   0.000910  ×   0.83
-10:              0.000050 0.000132   0.000082  ×   0.37
tip               0.000052 0.000085   0.000033  ×   0.61
0 + (-10000:)     0.028222 0.005337  -0.022885  ×   5.29
0                 0.023521 0.000084  -0.023437  × 280.01
(-10000:) + 0     0.235539 0.005308  -0.230231  ×  44.37
(-10:) + :9       0.232883 0.000180  -0.232703  ×1293.79
(-10000:) + (:99) 0.238735 0.005358  -0.233377  ×  44.55
:99 + (-10000:)   0.317942 0.005593  -0.312349  ×  56.84
:9 + (-10:)       0.313372 0.000179  -0.313193  ×1750.68
:9                0.316450 0.000143  -0.316307  ×2212.93


On smaller repositories, the cost of nodemap related operation is not as big, so
the win is much more modest. Yet it helps shaving a handful of millisecond here
and there.

Here are some numbers (in seconds) for the reference copy of mercurial:

Revset            Before   After     abs-change speedup
-10:              0.000065 0.000097   0.000032  × 0.67
tip               0.000063 0.000078   0.000015  × 0.80
0                 0.000561 0.000079  -0.000482  × 7.10
-10000:           0.004609 0.003648  -0.000961  × 1.26
0 + (-10000:)     0.005023 0.003715  -0.001307  × 1.35
(-10:) + :9       0.002187 0.000108  -0.002079  ×20.25
(-10000:) + 0     0.006252 0.003716  -0.002536  × 1.68
(-10000:) + (:99) 0.006367 0.003707  -0.002660  × 1.71
:9 + (-10:)       0.003846 0.000110  -0.003736  ×34.96
:9                0.003854 0.000099  -0.003755  ×38.92
:99 + (-10000:)   0.007644 0.003778  -0.003866  × 2.02

Differential Revision: https://phab.mercurial-scm.org/D7894

from __future__ import absolute_import, print_function

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__)