from __future__ import absolute_import
import sys
import unittest
import zlib
from mercurial import (
error,
ui as uimod,
wireprotoframing as framing,
)
from mercurial.utils import cborutil
try:
from mercurial import zstd
zstd.__version__
except ImportError:
zstd = None
ffs = framing.makeframefromhumanstring
globalui = uimod.ui()
def sendframe(reactor, frame):
"""Send a frame bytearray to a reactor."""
header = framing.parseheader(frame)
payload = frame[framing.FRAME_HEADER_SIZE :]
assert len(payload) == header.length
return reactor.onframerecv(
framing.frame(
header.requestid,
header.streamid,
header.streamflags,
header.typeid,
header.flags,
payload,
)
)
class SingleSendTests(unittest.TestCase):
"""A reactor that can only send once rejects subsequent sends."""
if not getattr(unittest.TestCase, 'assertRaisesRegex', False):
# Python 3.7 deprecates the regex*p* version, but 2.7 lacks
# the regex version.
assertRaisesRegex = ( # camelcase-required
unittest.TestCase.assertRaisesRegexp
)
def testbasic(self):
reactor = framing.clientreactor(
globalui, hasmultiplesend=False, buffersends=True
)
request, action, meta = reactor.callcommand(b'foo', {})
self.assertEqual(request.state, b'pending')
self.assertEqual(action, b'noop')
action, meta = reactor.flushcommands()
self.assertEqual(action, b'sendframes')
for frame in meta[b'framegen']:
self.assertEqual(request.state, b'sending')
self.assertEqual(request.state, b'sent')
with self.assertRaisesRegex(
error.ProgrammingError, 'cannot issue new commands'
):
reactor.callcommand(b'foo', {})
with self.assertRaisesRegex(
error.ProgrammingError, 'cannot issue new commands'
):
reactor.callcommand(b'foo', {})
class NoBufferTests(unittest.TestCase):
"""A reactor without send buffering sends requests immediately."""
def testbasic(self):
reactor = framing.clientreactor(
globalui, hasmultiplesend=True, buffersends=False
)
request, action, meta = reactor.callcommand(b'command1', {})
self.assertEqual(request.requestid, 1)
self.assertEqual(action, b'sendframes')
self.assertEqual(request.state, b'pending')
for frame in meta[b'framegen']:
self.assertEqual(request.state, b'sending')
self.assertEqual(request.state, b'sent')
action, meta = reactor.flushcommands()
self.assertEqual(action, b'noop')
# And we can send another command.
request, action, meta = reactor.callcommand(b'command2', {})
self.assertEqual(request.requestid, 3)
self.assertEqual(action, b'sendframes')
for frame in meta[b'framegen']:
self.assertEqual(request.state, b'sending')
self.assertEqual(request.state, b'sent')
class BadFrameRecvTests(unittest.TestCase):
if not getattr(unittest.TestCase, 'assertRaisesRegex', False):
# Python 3.7 deprecates the regex*p* version, but 2.7 lacks
# the regex version.
assertRaisesRegex = ( # camelcase-required
unittest.TestCase.assertRaisesRegexp
)
def testoddstream(self):
reactor = framing.clientreactor(globalui)
action, meta = sendframe(reactor, ffs(b'1 1 0 1 0 foo'))
self.assertEqual(action, b'error')
self.assertEqual(
meta[b'message'], b'received frame with odd numbered stream ID: 1'
)
def testunknownstream(self):
reactor = framing.clientreactor(globalui)
action, meta = sendframe(reactor, ffs(b'1 0 0 1 0 foo'))
self.assertEqual(action, b'error')
self.assertEqual(
meta[b'message'],
b'received frame on unknown stream without beginning '
b'of stream flag set',
)
def testunhandledframetype(self):
reactor = framing.clientreactor(globalui, buffersends=False)
request, action, meta = reactor.callcommand(b'foo', {})
for frame in meta[b'framegen']:
pass
with self.assertRaisesRegex(
error.ProgrammingError, 'unhandled frame type'
):
sendframe(reactor, ffs(b'1 0 stream-begin text-output 0 foo'))
class StreamTests(unittest.TestCase):
def testmultipleresponseframes(self):
reactor = framing.clientreactor(globalui, buffersends=False)
request, action, meta = reactor.callcommand(b'foo', {})
self.assertEqual(action, b'sendframes')
for f in meta[b'framegen']:
pass
action, meta = sendframe(
reactor,
ffs(
b'%d 0 stream-begin command-response 0 foo' % request.requestid
),
)
self.assertEqual(action, b'responsedata')
action, meta = sendframe(
reactor, ffs(b'%d 0 0 command-response eos bar' % request.requestid)
)
self.assertEqual(action, b'responsedata')
class RedirectTests(unittest.TestCase):
def testredirect(self):
reactor = framing.clientreactor(globalui, buffersends=False)
redirect = {
b'targets': [b'a', b'b'],
b'hashes': [b'sha256'],
}
request, action, meta = reactor.callcommand(
b'foo', {}, redirect=redirect
)
self.assertEqual(action, b'sendframes')
frames = list(meta[b'framegen'])
self.assertEqual(len(frames), 1)
self.assertEqual(
frames[0],
ffs(
b'1 1 stream-begin command-request new '
b"cbor:{b'name': b'foo', "
b"b'redirect': {b'targets': [b'a', b'b'], "
b"b'hashes': [b'sha256']}}"
),
)
class StreamSettingsTests(unittest.TestCase):
def testnoflags(self):
reactor = framing.clientreactor(globalui, buffersends=False)
request, action, meta = reactor.callcommand(b'foo', {})
for f in meta[b'framegen']:
pass
action, meta = sendframe(
reactor, ffs(b'1 2 stream-begin stream-settings 0 ')
)
self.assertEqual(action, b'error')
self.assertEqual(
meta,
{
b'message': b'stream encoding settings frame must have '
b'continuation or end of stream flag set',
},
)
def testconflictflags(self):
reactor = framing.clientreactor(globalui, buffersends=False)
request, action, meta = reactor.callcommand(b'foo', {})
for f in meta[b'framegen']:
pass
action, meta = sendframe(
reactor, ffs(b'1 2 stream-begin stream-settings continuation|eos ')
)
self.assertEqual(action, b'error')
self.assertEqual(
meta,
{
b'message': b'stream encoding settings frame cannot have both '
b'continuation and end of stream flags set',
},
)
def testemptypayload(self):
reactor = framing.clientreactor(globalui, buffersends=False)
request, action, meta = reactor.callcommand(b'foo', {})
for f in meta[b'framegen']:
pass
action, meta = sendframe(
reactor, ffs(b'1 2 stream-begin stream-settings eos ')
)
self.assertEqual(action, b'error')
self.assertEqual(
meta,
{
b'message': b'stream encoding settings frame did not contain '
b'CBOR data'
},
)
def testbadcbor(self):
reactor = framing.clientreactor(globalui, buffersends=False)
request, action, meta = reactor.callcommand(b'foo', {})
for f in meta[b'framegen']:
pass
action, meta = sendframe(
reactor, ffs(b'1 2 stream-begin stream-settings eos badvalue')
)
self.assertEqual(action, b'error')
def testsingleobject(self):
reactor = framing.clientreactor(globalui, buffersends=False)
request, action, meta = reactor.callcommand(b'foo', {})
for f in meta[b'framegen']:
pass
action, meta = sendframe(
reactor,
ffs(b'1 2 stream-begin stream-settings eos cbor:b"identity"'),
)
self.assertEqual(action, b'noop')
self.assertEqual(meta, {})
def testmultipleobjects(self):
reactor = framing.clientreactor(globalui, buffersends=False)
request, action, meta = reactor.callcommand(b'foo', {})
for f in meta[b'framegen']:
pass
data = b''.join(
[
b''.join(cborutil.streamencode(b'identity')),
b''.join(cborutil.streamencode({b'foo', b'bar'})),
]
)
action, meta = sendframe(
reactor, ffs(b'1 2 stream-begin stream-settings eos %s' % data)
)
self.assertEqual(action, b'error')
self.assertEqual(
meta,
{
b'message': b'error setting stream decoder: identity decoder '
b'received unexpected additional values',
},
)
def testmultipleframes(self):
reactor = framing.clientreactor(globalui, buffersends=False)
request, action, meta = reactor.callcommand(b'foo', {})
for f in meta[b'framegen']:
pass
data = b''.join(cborutil.streamencode(b'identity'))
action, meta = sendframe(
reactor,
ffs(
b'1 2 stream-begin stream-settings continuation %s' % data[0:3]
),
)
self.assertEqual(action, b'noop')
self.assertEqual(meta, {})
action, meta = sendframe(
reactor, ffs(b'1 2 0 stream-settings eos %s' % data[3:])
)
self.assertEqual(action, b'noop')
self.assertEqual(meta, {})
def testinvalidencoder(self):
reactor = framing.clientreactor(globalui, buffersends=False)
request, action, meta = reactor.callcommand(b'foo', {})
for f in meta[b'framegen']:
pass
action, meta = sendframe(
reactor,
ffs(b'1 2 stream-begin stream-settings eos cbor:b"badvalue"'),
)
self.assertEqual(action, b'error')
self.assertEqual(
meta,
{
b'message': b'error setting stream decoder: unknown stream '
b'decoder: badvalue',
},
)
def testzlibencoding(self):
reactor = framing.clientreactor(globalui, buffersends=False)
request, action, meta = reactor.callcommand(b'foo', {})
for f in meta[b'framegen']:
pass
action, meta = sendframe(
reactor,
ffs(
b'%d 2 stream-begin stream-settings eos cbor:b"zlib"'
% request.requestid
),
)
self.assertEqual(action, b'noop')
self.assertEqual(meta, {})
result = {
b'status': b'ok',
}
encoded = b''.join(cborutil.streamencode(result))
compressed = zlib.compress(encoded)
self.assertEqual(zlib.decompress(compressed), encoded)
action, meta = sendframe(
reactor,
ffs(
b'%d 2 encoded command-response eos %s'
% (request.requestid, compressed)
),
)
self.assertEqual(action, b'responsedata')
self.assertEqual(meta[b'data'], encoded)
def testzlibencodingsinglebyteframes(self):
reactor = framing.clientreactor(globalui, buffersends=False)
request, action, meta = reactor.callcommand(b'foo', {})
for f in meta[b'framegen']:
pass
action, meta = sendframe(
reactor,
ffs(
b'%d 2 stream-begin stream-settings eos cbor:b"zlib"'
% request.requestid
),
)
self.assertEqual(action, b'noop')
self.assertEqual(meta, {})
result = {
b'status': b'ok',
}
encoded = b''.join(cborutil.streamencode(result))
compressed = zlib.compress(encoded)
self.assertEqual(zlib.decompress(compressed), encoded)
chunks = []
for i in range(len(compressed)):
char = compressed[i : i + 1]
if char == b'\\':
char = b'\\\\'
action, meta = sendframe(
reactor,
ffs(
b'%d 2 encoded command-response continuation %s'
% (request.requestid, char)
),
)
self.assertEqual(action, b'responsedata')
chunks.append(meta[b'data'])
self.assertTrue(meta[b'expectmore'])
self.assertFalse(meta[b'eos'])
# zlib will have the full data decoded at this point, even though
# we haven't flushed.
self.assertEqual(b''.join(chunks), encoded)
# End the stream for good measure.
action, meta = sendframe(
reactor,
ffs(b'%d 2 stream-end command-response eos ' % request.requestid),
)
self.assertEqual(action, b'responsedata')
self.assertEqual(meta[b'data'], b'')
self.assertFalse(meta[b'expectmore'])
self.assertTrue(meta[b'eos'])
def testzlibmultipleresponses(self):
# We feed in zlib compressed data on the same stream but belonging to
# 2 different requests. This tests our flushing behavior.
reactor = framing.clientreactor(
globalui, buffersends=False, hasmultiplesend=True
)
request1, action, meta = reactor.callcommand(b'foo', {})
for f in meta[b'framegen']:
pass
request2, action, meta = reactor.callcommand(b'foo', {})
for f in meta[b'framegen']:
pass
outstream = framing.outputstream(2)
outstream.setencoder(globalui, b'zlib')
response1 = b''.join(
cborutil.streamencode(
{b'status': b'ok', b'extra': b'response1' * 10,}
)
)
response2 = b''.join(
cborutil.streamencode(
{b'status': b'error', b'extra': b'response2' * 10,}
)
)
action, meta = sendframe(
reactor,
ffs(
b'%d 2 stream-begin stream-settings eos cbor:b"zlib"'
% request1.requestid
),
)
self.assertEqual(action, b'noop')
self.assertEqual(meta, {})
# Feeding partial data in won't get anything useful out.
action, meta = sendframe(
reactor,
ffs(
b'%d 2 encoded command-response continuation %s'
% (request1.requestid, outstream.encode(response1))
),
)
self.assertEqual(action, b'responsedata')
self.assertEqual(meta[b'data'], b'')
# But flushing data at both ends will get our original data.
action, meta = sendframe(
reactor,
ffs(
b'%d 2 encoded command-response eos %s'
% (request1.requestid, outstream.flush())
),
)
self.assertEqual(action, b'responsedata')
self.assertEqual(meta[b'data'], response1)
# We should be able to reuse the compressor/decompressor for the
# 2nd response.
action, meta = sendframe(
reactor,
ffs(
b'%d 2 encoded command-response continuation %s'
% (request2.requestid, outstream.encode(response2))
),
)
self.assertEqual(action, b'responsedata')
self.assertEqual(meta[b'data'], b'')
action, meta = sendframe(
reactor,
ffs(
b'%d 2 encoded command-response eos %s'
% (request2.requestid, outstream.flush())
),
)
self.assertEqual(action, b'responsedata')
self.assertEqual(meta[b'data'], response2)
@unittest.skipUnless(zstd, 'zstd not available')
def testzstd8mbencoding(self):
reactor = framing.clientreactor(globalui, buffersends=False)
request, action, meta = reactor.callcommand(b'foo', {})
for f in meta[b'framegen']:
pass
action, meta = sendframe(
reactor,
ffs(
b'%d 2 stream-begin stream-settings eos cbor:b"zstd-8mb"'
% request.requestid
),
)
self.assertEqual(action, b'noop')
self.assertEqual(meta, {})
result = {
b'status': b'ok',
}
encoded = b''.join(cborutil.streamencode(result))
encoder = framing.zstd8mbencoder(globalui)
compressed = encoder.encode(encoded) + encoder.finish()
self.assertEqual(
zstd.ZstdDecompressor().decompress(
compressed, max_output_size=len(encoded)
),
encoded,
)
action, meta = sendframe(
reactor,
ffs(
b'%d 2 encoded command-response eos %s'
% (request.requestid, compressed)
),
)
self.assertEqual(action, b'responsedata')
self.assertEqual(meta[b'data'], encoded)
@unittest.skipUnless(zstd, 'zstd not available')
def testzstd8mbencodingsinglebyteframes(self):
reactor = framing.clientreactor(globalui, buffersends=False)
request, action, meta = reactor.callcommand(b'foo', {})
for f in meta[b'framegen']:
pass
action, meta = sendframe(
reactor,
ffs(
b'%d 2 stream-begin stream-settings eos cbor:b"zstd-8mb"'
% request.requestid
),
)
self.assertEqual(action, b'noop')
self.assertEqual(meta, {})
result = {
b'status': b'ok',
}
encoded = b''.join(cborutil.streamencode(result))
compressed = zstd.ZstdCompressor().compress(encoded)
self.assertEqual(
zstd.ZstdDecompressor().decompress(compressed), encoded
)
chunks = []
for i in range(len(compressed)):
char = compressed[i : i + 1]
if char == b'\\':
char = b'\\\\'
action, meta = sendframe(
reactor,
ffs(
b'%d 2 encoded command-response continuation %s'
% (request.requestid, char)
),
)
self.assertEqual(action, b'responsedata')
chunks.append(meta[b'data'])
self.assertTrue(meta[b'expectmore'])
self.assertFalse(meta[b'eos'])
# zstd decompressor will flush at frame boundaries.
self.assertEqual(b''.join(chunks), encoded)
# End the stream for good measure.
action, meta = sendframe(
reactor,
ffs(b'%d 2 stream-end command-response eos ' % request.requestid),
)
self.assertEqual(action, b'responsedata')
self.assertEqual(meta[b'data'], b'')
self.assertFalse(meta[b'expectmore'])
self.assertTrue(meta[b'eos'])
@unittest.skipUnless(zstd, 'zstd not available')
def testzstd8mbmultipleresponses(self):
# We feed in zstd compressed data on the same stream but belonging to
# 2 different requests. This tests our flushing behavior.
reactor = framing.clientreactor(
globalui, buffersends=False, hasmultiplesend=True
)
request1, action, meta = reactor.callcommand(b'foo', {})
for f in meta[b'framegen']:
pass
request2, action, meta = reactor.callcommand(b'foo', {})
for f in meta[b'framegen']:
pass
outstream = framing.outputstream(2)
outstream.setencoder(globalui, b'zstd-8mb')
response1 = b''.join(
cborutil.streamencode(
{b'status': b'ok', b'extra': b'response1' * 10,}
)
)
response2 = b''.join(
cborutil.streamencode(
{b'status': b'error', b'extra': b'response2' * 10,}
)
)
action, meta = sendframe(
reactor,
ffs(
b'%d 2 stream-begin stream-settings eos cbor:b"zstd-8mb"'
% request1.requestid
),
)
self.assertEqual(action, b'noop')
self.assertEqual(meta, {})
# Feeding partial data in won't get anything useful out.
action, meta = sendframe(
reactor,
ffs(
b'%d 2 encoded command-response continuation %s'
% (request1.requestid, outstream.encode(response1))
),
)
self.assertEqual(action, b'responsedata')
self.assertEqual(meta[b'data'], b'')
# But flushing data at both ends will get our original data.
action, meta = sendframe(
reactor,
ffs(
b'%d 2 encoded command-response eos %s'
% (request1.requestid, outstream.flush())
),
)
self.assertEqual(action, b'responsedata')
self.assertEqual(meta[b'data'], response1)
# We should be able to reuse the compressor/decompressor for the
# 2nd response.
action, meta = sendframe(
reactor,
ffs(
b'%d 2 encoded command-response continuation %s'
% (request2.requestid, outstream.encode(response2))
),
)
self.assertEqual(action, b'responsedata')
self.assertEqual(meta[b'data'], b'')
action, meta = sendframe(
reactor,
ffs(
b'%d 2 encoded command-response eos %s'
% (request2.requestid, outstream.flush())
),
)
self.assertEqual(action, b'responsedata')
self.assertEqual(meta[b'data'], response2)
if __name__ == '__main__':
if (3, 6, 0) <= sys.version_info < (3, 6, 4):
# Python 3.6.0 through 3.6.3 inclusive shipped with
# https://bugs.python.org/issue31825 and we can't run these
# tests on those specific versions of Python. Sigh.
sys.exit(80)
import silenttestrunner
silenttestrunner.main(__name__)