( )⚙ D5678 py3: port test-batching.py to python3

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5678

py3: port test-batching.py to python3
ClosedPublic

Authored by durin42 on Jan 24 2019, 11:40 AM.

Details

Reviewers
pulkit
Group Reviewers
hg-reviewers
Commits
rHGb81ca9a3f4e4: py3: port test-batching.py to python3
Summary

I used byteify-strings.py on this file, then manually added the
various pycompat and bprint bits as needed.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

durin42 created this revision.Jan 24 2019, 11:40 AM
pulkit accepted this revision.Jan 24 2019, 11:50 AM
Closed by commit rHGb81ca9a3f4e4: py3: port test-batching.py to python3 (authored by durin42). · Explain WhyJan 24 2019, 12:03 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mcontrib/python3-whitelist (1 line)
Mtests/test-batching.py (102 lines)

Diff 13399

contrib/python3-whitelist

test-audit-path.t test-audit-path.t
test-audit-subrepo.t test-audit-subrepo.t
test-automv.t test-automv.t
test-backout.t test-backout.t
test-backwards-remove.t test-backwards-remove.t
test-bad-extension.t test-bad-extension.t
test-bad-pull.t test-bad-pull.t
test-basic.t test-basic.t
test-batching.py
test-bdiff.py test-bdiff.py
test-bheads.t test-bheads.t
test-bisect.t test-bisect.t
test-bisect2.t test-bisect2.t
test-bisect3.t test-bisect3.t
test-blackbox.t test-blackbox.t
test-bookflow.t test-bookflow.t
test-bookmarks-current.t test-bookmarks-current.t

tests/test-batching.py

# test-batching.py - tests for transparent command batching # test-batching.py - tests for transparent command batching
# #
# Copyright 2011 Peter Arrenbrecht <peter@arrenbrecht.ch> # Copyright 2011 Peter Arrenbrecht <peter@arrenbrecht.ch>
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
import contextlib import contextlib
from mercurial import ( from mercurial import (
localrepo, localrepo,
pycompat,
wireprotov1peer, wireprotov1peer,
) )
def bprint(*bs):
print(*[pycompat.sysstr(b) for b in bs])
# equivalent of repo.repository # equivalent of repo.repository
class thing(object): class thing(object):
def hello(self): def hello(self):
return "Ready." return b"Ready."
# equivalent of localrepo.localrepository # equivalent of localrepo.localrepository
class localthing(thing): class localthing(thing):
def foo(self, one, two=None): def foo(self, one, two=None):
if one: if one:
return "%s and %s" % (one, two,) return b"%s and %s" % (one, two,)
return "Nope" return b"Nope"
def bar(self, b, a): def bar(self, b, a):
return "%s und %s" % (b, a,) return b"%s und %s" % (b, a,)
def greet(self, name=None): def greet(self, name=None):
return "Hello, %s" % name return b"Hello, %s" % name
@contextlib.contextmanager @contextlib.contextmanager
def commandexecutor(self): def commandexecutor(self):
e = localrepo.localcommandexecutor(self) e = localrepo.localcommandexecutor(self)
try: try:
yield e yield e
finally: finally:
e.close() e.close()
# usage of "thing" interface # usage of "thing" interface
def use(it): def use(it):
# Direct call to base method shared between client and server. # 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. # Direct calls to proxied methods. They cause individual roundtrips.
print(it.foo("Un", two="Deux")) bprint(it.foo(b"Un", two=b"Deux"))
print(it.bar("Eins", "Zwei")) bprint(it.bar(b"Eins", b"Zwei"))
# Batched call to a couple of proxied methods. # Batched call to a couple of proxied methods.
with it.commandexecutor() as e: with it.commandexecutor() as e:
ffoo = e.callcommand('foo', {'one': 'One', 'two': 'Two'}) ffoo = e.callcommand(b'foo', {b'one': b'One', b'two': b'Two'})
fbar = e.callcommand('bar', {'b': 'Eins', 'a': 'Zwei'}) fbar = e.callcommand(b'bar', {b'b': b'Eins', b'a': b'Zwei'})
fbar2 = e.callcommand('bar', {'b': 'Uno', 'a': 'Due'}) fbar2 = e.callcommand(b'bar', {b'b': b'Uno', b'a': b'Due'})
print(ffoo.result()) bprint(ffoo.result())
print(fbar.result()) bprint(fbar.result())
print(fbar2.result()) bprint(fbar2.result())
# local usage # local usage
mylocal = localthing() mylocal = localthing()
print() print()
print("== Local") bprint(b"== Local")
use(mylocal) use(mylocal)
# demo remoting; mimicks what wireproto and HTTP/SSH do # demo remoting; mimicks what wireproto and HTTP/SSH do
# shared # shared
def escapearg(plain): def escapearg(plain):
return (plain return (plain
.replace(':', '::') .replace(b':', b'::')
.replace(',', ':,') .replace(b',', b':,')
.replace(';', ':;') .replace(b';', b':;')
.replace('=', ':=')) .replace(b'=', b':='))
def unescapearg(escaped): def unescapearg(escaped):
return (escaped return (escaped
.replace(':=', '=') .replace(b':=', b'=')
.replace(':;', ';') .replace(b':;', b';')
.replace(':,', ',') .replace(b':,', b',')
.replace('::', ':')) .replace(b'::', b':'))
# server side # server side
# equivalent of wireproto's global functions # equivalent of wireproto's global functions
class server(object): class server(object):
def __init__(self, local): def __init__(self, local):
self.local = local self.local = local
def _call(self, name, args): 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) return getattr(self, name)(**args)
def perform(self, req): def perform(self, req):
print("REQ:", req) bprint(b"REQ:", req)
name, args = req.split('?', 1) name, args = req.split(b'?', 1)
args = args.split('&') args = args.split(b'&')
vals = dict(arg.split('=', 1) for arg in args) vals = dict(arg.split(b'=', 1) for arg in args)
res = getattr(self, name)(**vals) res = getattr(self, pycompat.sysstr(name))(**pycompat.strkwargs(vals))
print(" ->", res) bprint(b" ->", res)
return res return res
def batch(self, cmds): def batch(self, cmds):
res = [] res = []
for pair in cmds.split(';'): for pair in cmds.split(b';'):
name, args = pair.split(':', 1) name, args = pair.split(b':', 1)
vals = {} vals = {}
for a in args.split(','): for a in args.split(b','):
if a: if a:
n, v = a.split('=') n, v = a.split(b'=')
vals[n] = unescapearg(v) vals[n] = unescapearg(v)
res.append(escapearg(getattr(self, name)(**vals))) res.append(escapearg(getattr(self, pycompat.sysstr(name))(
return ';'.join(res) **pycompat.strkwargs(vals))))
return b';'.join(res)
def foo(self, one, two): def foo(self, one, two):
return mangle(self.local.foo(unmangle(one), unmangle(two))) return mangle(self.local.foo(unmangle(one), unmangle(two)))
def bar(self, b, a): def bar(self, b, a):
return mangle(self.local.bar(unmangle(b), unmangle(a))) return mangle(self.local.bar(unmangle(b), unmangle(a)))
def greet(self, name): def greet(self, name):
return mangle(self.local.greet(unmangle(name))) return mangle(self.local.greet(unmangle(name)))
myserver = server(mylocal) myserver = server(mylocal)
# local side # local side
# equivalent of wireproto.encode/decodelist, that is, type-specific marshalling # 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 # here we just transform the strings a bit to check we're properly en-/decoding
def mangle(s): 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): 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 # equivalent of wireproto.wirerepository and something like http's wire format
class remotething(thing): class remotething(thing):
def __init__(self, server): def __init__(self, server):
self.server = server self.server = server
def _submitone(self, name, args): 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) return self.server.perform(req)
def _submitbatch(self, cmds): def _submitbatch(self, cmds):
req = [] req = []
for name, args in cmds: for name, args in cmds:
args = ','.join(n + '=' + escapearg(v) for n, v in args) args = b','.join(n + b'=' + escapearg(v) for n, v in args)
req.append(name + ':' + args) req.append(name + b':' + args)
req = ';'.join(req) req = b';'.join(req)
res = self._submitone('batch', [('cmds', req,)]) res = self._submitone(b'batch', [(b'cmds', req,)])
for r in res.split(';'): for r in res.split(b';'):
yield r yield r
@contextlib.contextmanager @contextlib.contextmanager
def commandexecutor(self): def commandexecutor(self):
e = wireprotov1peer.peerexecutor(self) e = wireprotov1peer.peerexecutor(self)
try: try:
yield e yield e
finally: finally:
e.close() e.close()
@wireprotov1peer.batchable @wireprotov1peer.batchable
def foo(self, one, two=None): 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() encresref = wireprotov1peer.future()
yield encargs, encresref yield encargs, encresref
yield unmangle(encresref.value) yield unmangle(encresref.value)
@wireprotov1peer.batchable @wireprotov1peer.batchable
def bar(self, b, a): def bar(self, b, a):
encresref = wireprotov1peer.future() 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) yield unmangle(encresref.value)
# greet is coded directly. It therefore does not support batching. If it # 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 # does appear in a batch, the batch is split around greet, and the call to
# greet is done in its own roundtrip. # greet is done in its own roundtrip.
def greet(self, name=None): 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 # demo remote usage
myproxy = remotething(myserver) myproxy = remotething(myserver)
print() print()
print("== Remote") bprint(b"== Remote")
use(myproxy) use(myproxy)