tests/test-template-engine.t

debugcommands: allow sending of simple commands with debugwireproto

Previously, we only had support for low-level "raw" operations.

A goal of `hg debugwireproto` is to allow easily performing
higher-level primitives, such as sending a wire protocol command
and reading its response.

We implement a "command" action that does just this.

Currently, we only support simple commands (those without payloads).
We have basic support for sending command arguments. We don't yet
support sending dictionary arguments. This will be implemented later.

To prove it works, we add tests to test-ssh-proto.t that send some
"listkeys" commands.

Note: we don't observe/report os.read() events because these may not be
deterministic. We instead observe/report the read() and readline()
operations on the bufferedinputpipe. These *should* be deterministic.

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

  $ cat > engine.py << EOF
  > 
  > from mercurial import templater
  > 
  > class mytemplater(object):
  >     def __init__(self, loader, filters, defaults, resources, aliases):
  >         self.loader = loader
  >         self._defaults = defaults
  >         self._resources = resources
  > 
  >     def symbol(self, mapping, key):
  >         return mapping[key]
  > 
  >     def resource(self, mapping, key):
  >         v = self._resources[key]
  >         if v is None:
  >             v = mapping[key]
  >         return v
  > 
  >     def process(self, t, map):
  >         tmpl = self.loader(t)
  >         props = self._defaults.copy()
  >         props.update(map)
  >         for k, v in props.items():
  >             if k in ('templ', 'ctx', 'repo', 'revcache', 'cache', 'troubles'):
  >                 continue
  >             if callable(v) and getattr(v, '_requires', None) is None:
  >                 props = self._resources.copy()
  >                 props.update(map)
  >                 v = v(**props)
  >             elif callable(v):
  >                 v = v(self, props)
  >             v = templater.stringify(v)
  >             tmpl = tmpl.replace('{{%s}}' % k, v)
  >         yield tmpl
  > 
  > templater.engines['my'] = mytemplater
  > EOF
  $ hg init test
  $ echo '[extensions]' > test/.hg/hgrc
  $ echo "engine = `pwd`/engine.py" >> test/.hg/hgrc
  $ cd test
  $ cat > mymap << EOF
  > changeset = my:changeset.txt
  > EOF
  $ cat > changeset.txt << EOF
  > {{rev}} {{node}} {{author}}
  > EOF
  $ hg ci -Ama
  adding changeset.txt
  adding mymap
  $ hg log --style=./mymap
  0 97e5f848f0936960273bbf75be6388cd0350a32b test

  $ cat > changeset.txt << EOF
  > {{p1rev}} {{p1node}} {{p2rev}} {{p2node}}
  > EOF
  $ hg ci -Ama
  $ hg log --style=./mymap
  0 97e5f848f0936960273bbf75be6388cd0350a32b -1 0000000000000000000000000000000000000000
  -1 0000000000000000000000000000000000000000 -1 0000000000000000000000000000000000000000

invalid engine type:

  $ echo 'changeset = unknown:changeset.txt' > unknownenginemap
  $ hg log --style=./unknownenginemap
  abort: invalid template engine: unknown
  [255]

  $ cd ..