diff --git a/contrib/python3-whitelist b/contrib/python3-whitelist --- a/contrib/python3-whitelist +++ b/contrib/python3-whitelist @@ -26,6 +26,7 @@ test-bad-extension.t test-bad-pull.t test-basic.t +test-batching.py test-bdiff.py test-bheads.t test-bisect.t diff --git a/tests/test-batching.py b/tests/test-batching.py --- a/tests/test-batching.py +++ b/tests/test-batching.py @@ -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)