--- a/tests/test-batching.py Thu Jan 24 11:34:18 2019 -0500
+++ b/tests/test-batching.py Thu Jan 24 11:35:40 2019 -0500
@@ -11,25 +11,28 @@
from mercurial import (
localrepo,
+ pycompat,
wireprotov1peer,
+)
-)
+def bprint(*bs):
+ print(*[pycompat.sysstr(b) for b in bs])
# equivalent of repo.repository
class thing(object):
def hello(self):
- return "Ready."
+ return b"Ready."
# equivalent of localrepo.localrepository
class localthing(thing):
def foo(self, one, two=None):
if one:
- return "%s and %s" % (one, two,)
- return "Nope"
+ return b"%s and %s" % (one, two,)
+ return b"Nope"
def bar(self, b, a):
- return "%s und %s" % (b, a,)
+ return b"%s und %s" % (b, a,)
def greet(self, name=None):
- return "Hello, %s" % name
+ return b"Hello, %s" % name
@contextlib.contextmanager
def commandexecutor(self):
@@ -43,27 +46,27 @@
def use(it):
# Direct call to base method shared between client and server.
- print(it.hello())
+ bprint(it.hello())
# Direct calls to proxied methods. They cause individual roundtrips.
- print(it.foo("Un", two="Deux"))
- print(it.bar("Eins", "Zwei"))
+ bprint(it.foo(b"Un", two=b"Deux"))
+ bprint(it.bar(b"Eins", b"Zwei"))
# Batched call to a couple of proxied methods.
with it.commandexecutor() as e:
- ffoo = e.callcommand('foo', {'one': 'One', 'two': 'Two'})
- fbar = e.callcommand('bar', {'b': 'Eins', 'a': 'Zwei'})
- fbar2 = e.callcommand('bar', {'b': 'Uno', 'a': 'Due'})
+ ffoo = e.callcommand(b'foo', {b'one': b'One', b'two': b'Two'})
+ fbar = e.callcommand(b'bar', {b'b': b'Eins', b'a': b'Zwei'})
+ fbar2 = e.callcommand(b'bar', {b'b': b'Uno', b'a': b'Due'})
- print(ffoo.result())
- print(fbar.result())
- print(fbar2.result())
+ bprint(ffoo.result())
+ bprint(fbar.result())
+ bprint(fbar2.result())
# local usage
mylocal = localthing()
print()
-print("== Local")
+bprint(b"== Local")
use(mylocal)
# demo remoting; mimicks what wireproto and HTTP/SSH do
@@ -72,16 +75,16 @@
def escapearg(plain):
return (plain
- .replace(':', '::')
- .replace(',', ':,')
- .replace(';', ':;')
- .replace('=', ':='))
+ .replace(b':', b'::')
+ .replace(b',', b':,')
+ .replace(b';', b':;')
+ .replace(b'=', b':='))
def unescapearg(escaped):
return (escaped
- .replace(':=', '=')
- .replace(':;', ';')
- .replace(':,', ',')
- .replace('::', ':'))
+ .replace(b':=', b'=')
+ .replace(b':;', b';')
+ .replace(b':,', b',')
+ .replace(b'::', b':'))
# server side
@@ -90,27 +93,28 @@
def __init__(self, local):
self.local = local
def _call(self, name, args):
- args = dict(arg.split('=', 1) for arg in args)
+ args = dict(arg.split(b'=', 1) for arg in args)
return getattr(self, name)(**args)
def perform(self, req):
- print("REQ:", req)
- name, args = req.split('?', 1)
- args = args.split('&')
- vals = dict(arg.split('=', 1) for arg in args)
- res = getattr(self, name)(**vals)
- print(" ->", res)
+ bprint(b"REQ:", req)
+ name, args = req.split(b'?', 1)
+ args = args.split(b'&')
+ vals = dict(arg.split(b'=', 1) for arg in args)
+ res = getattr(self, pycompat.sysstr(name))(**pycompat.strkwargs(vals))
+ bprint(b" ->", res)
return res
def batch(self, cmds):
res = []
- for pair in cmds.split(';'):
- name, args = pair.split(':', 1)
+ for pair in cmds.split(b';'):
+ name, args = pair.split(b':', 1)
vals = {}
- for a in args.split(','):
+ for a in args.split(b','):
if a:
- n, v = a.split('=')
+ n, v = a.split(b'=')
vals[n] = unescapearg(v)
- res.append(escapearg(getattr(self, name)(**vals)))
- return ';'.join(res)
+ res.append(escapearg(getattr(self, pycompat.sysstr(name))(
+ **pycompat.strkwargs(vals))))
+ return b';'.join(res)
def foo(self, one, two):
return mangle(self.local.foo(unmangle(one), unmangle(two)))
def bar(self, b, a):
@@ -124,25 +128,25 @@
# equivalent of wireproto.encode/decodelist, that is, type-specific marshalling
# here we just transform the strings a bit to check we're properly en-/decoding
def mangle(s):
- return ''.join(chr(ord(c) + 1) for c in s)
+ return b''.join(pycompat.bytechr(ord(c) + 1) for c in pycompat.bytestr(s))
def unmangle(s):
- return ''.join(chr(ord(c) - 1) for c in s)
+ return b''.join(pycompat.bytechr(ord(c) - 1) for c in pycompat.bytestr(s))
# equivalent of wireproto.wirerepository and something like http's wire format
class remotething(thing):
def __init__(self, server):
self.server = server
def _submitone(self, name, args):
- req = name + '?' + '&'.join(['%s=%s' % (n, v) for n, v in args])
+ req = name + b'?' + b'&'.join([b'%s=%s' % (n, v) for n, v in args])
return self.server.perform(req)
def _submitbatch(self, cmds):
req = []
for name, args in cmds:
- args = ','.join(n + '=' + escapearg(v) for n, v in args)
- req.append(name + ':' + args)
- req = ';'.join(req)
- res = self._submitone('batch', [('cmds', req,)])
- for r in res.split(';'):
+ args = b','.join(n + b'=' + escapearg(v) for n, v in args)
+ req.append(name + b':' + args)
+ req = b';'.join(req)
+ res = self._submitone(b'batch', [(b'cmds', req,)])
+ for r in res.split(b';'):
yield r
@contextlib.contextmanager
@@ -155,7 +159,7 @@
@wireprotov1peer.batchable
def foo(self, one, two=None):
- encargs = [('one', mangle(one),), ('two', mangle(two),)]
+ encargs = [(b'one', mangle(one),), (b'two', mangle(two),)]
encresref = wireprotov1peer.future()
yield encargs, encresref
yield unmangle(encresref.value)
@@ -163,18 +167,18 @@
@wireprotov1peer.batchable
def bar(self, b, a):
encresref = wireprotov1peer.future()
- yield [('b', mangle(b),), ('a', mangle(a),)], encresref
+ yield [(b'b', mangle(b),), (b'a', mangle(a),)], encresref
yield unmangle(encresref.value)
# greet is coded directly. It therefore does not support batching. If it
# does appear in a batch, the batch is split around greet, and the call to
# greet is done in its own roundtrip.
def greet(self, name=None):
- return unmangle(self._submitone('greet', [('name', mangle(name),)]))
+ return unmangle(self._submitone(b'greet', [(b'name', mangle(name),)]))
# demo remote usage
myproxy = remotething(myserver)
print()
-print("== Remote")
+bprint(b"== Remote")
use(myproxy)