tests: quiet strip to avoid commandserver pathsep issue

tests/test-commandserver.py

@@ -1,282 +1,282 b''
 import sys, os, struct, subprocess, cStringIO, re, shutil
 
 def connect(path=None):
     cmdline = ['hg', 'serve', '--cmdserver', 'pipe']
     if path:
         cmdline += ['-R', path]
 
     server = subprocess.Popen(cmdline, stdin=subprocess.PIPE,
                               stdout=subprocess.PIPE)
 
     return server
 
 def writeblock(server, data):
     server.stdin.write(struct.pack('>I', len(data)))
     server.stdin.write(data)
     server.stdin.flush()
 
 def readchannel(server):
     data = server.stdout.read(5)
     if not data:
         raise EOFError
     channel, length = struct.unpack('>cI', data)
     if channel in 'IL':
         return channel, length
     else:
         return channel, server.stdout.read(length)
 
 def runcommand(server, args, output=sys.stdout, error=sys.stderr, input=None):
     print ' runcommand', ' '.join(args)
     sys.stdout.flush()
     server.stdin.write('runcommand\n')
     writeblock(server, '\0'.join(args))
 
     if not input:
         input = cStringIO.StringIO()
 
     while True:
         ch, data = readchannel(server)
         if ch == 'o':
             output.write(data)
             output.flush()
         elif ch == 'e':
             error.write(data)
             error.flush()
         elif ch == 'I':
             writeblock(server, input.read(data))
         elif ch == 'L':
             writeblock(server, input.readline(data))
         elif ch == 'r':
             return struct.unpack('>i', data)[0]
         else:
             print "unexpected channel %c: %r" % (ch, data)
             if ch.isupper():
                 return
 
 def check(func, repopath=None):
     print
     print 'testing %s:' % func.__name__
     print
     sys.stdout.flush()
     server = connect(repopath)
     try:
         return func(server)
     finally:
         server.stdin.close()
         server.wait()
 
 def unknowncommand(server):
     server.stdin.write('unknowncommand\n')
 
 def hellomessage(server):
     ch, data = readchannel(server)
     # escaping python tests output not supported
     print '%c, %r' % (ch, re.sub('encoding: [a-zA-Z0-9-]+', 'encoding: ***',
                                  data))
 
     # run an arbitrary command to make sure the next thing the server sends
     # isn't part of the hello message
     runcommand(server, ['id'])
 
 def checkruncommand(server):
     # hello block
     readchannel(server)
 
     # no args
     runcommand(server, [])
 
     # global options
     runcommand(server, ['id', '--quiet'])
 
     # make sure global options don't stick through requests
     runcommand(server, ['id'])
 
     # --config
     runcommand(server, ['id', '--config', 'ui.quiet=True'])
 
     # make sure --config doesn't stick
     runcommand(server, ['id'])
 
 def inputeof(server):
     readchannel(server)
     server.stdin.write('runcommand\n')
     # close stdin while server is waiting for input
     server.stdin.close()
 
     # server exits with 1 if the pipe closed while reading the command
     print 'server exit code =', server.wait()
 
 def serverinput(server):
     readchannel(server)
 
     patch = """
 # HG changeset patch
 # User test
 # Date 0 0
 # Node ID c103a3dec114d882c98382d684d8af798d09d857
 # Parent  0000000000000000000000000000000000000000
 1
 
 diff -r 000000000000 -r c103a3dec114 a
 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
 +++ b/a	Thu Jan 01 00:00:00 1970 +0000
 @@ -0,0 +1,1 @@
 +1
 """
 
     runcommand(server, ['import', '-'], input=cStringIO.StringIO(patch))
     runcommand(server, ['log'])
 
 def cwd(server):
     """ check that --cwd doesn't persist between requests """
     readchannel(server)
     os.mkdir('foo')
     f = open('foo/bar', 'wb')
     f.write('a')
     f.close()
     runcommand(server, ['--cwd', 'foo', 'st', 'bar'])
     runcommand(server, ['st', 'foo/bar'])
     os.remove('foo/bar')
 
 def localhgrc(server):
     """ check that local configs for the cached repo aren't inherited when -R
     is used """
     readchannel(server)
 
     # the cached repo local hgrc contains ui.foo=bar, so showconfig should
     # show it
     runcommand(server, ['showconfig'])
 
     # but not for this repo
     runcommand(server, ['init', 'foo'])
     runcommand(server, ['-R', 'foo', 'showconfig', 'ui', 'defaults'])
     shutil.rmtree('foo')
 
 def hook(**args):
     print 'hook talking'
     print 'now try to read something: %r' % sys.stdin.read()
 
 def hookoutput(server):
     readchannel(server)
     runcommand(server, ['--config',
                         'hooks.pre-identify=python:test-commandserver.hook',
                         'id'],
                input=cStringIO.StringIO('some input'))
 
 def outsidechanges(server):
     readchannel(server)
     f = open('a', 'ab')
     f.write('a\n')
     f.close()
     runcommand(server, ['status'])
     os.system('hg ci -Am2')
     runcommand(server, ['tip'])
     runcommand(server, ['status'])
 
 def bookmarks(server):
     readchannel(server)
     runcommand(server, ['bookmarks'])
 
     # changes .hg/bookmarks
     os.system('hg bookmark -i bm1')
     os.system('hg bookmark -i bm2')
     runcommand(server, ['bookmarks'])
 
     # changes .hg/bookmarks.current
     os.system('hg upd bm1 -q')
     runcommand(server, ['bookmarks'])
 
     runcommand(server, ['bookmarks', 'bm3'])
     f = open('a', 'ab')
     f.write('a\n')
     f.close()
     runcommand(server, ['commit', '-Amm'])
     runcommand(server, ['bookmarks'])
 
 def tagscache(server):
     readchannel(server)
     runcommand(server, ['id', '-t', '-r', '0'])
     os.system('hg tag -r 0 foo')
     runcommand(server, ['id', '-t', '-r', '0'])
 
 def setphase(server):
     readchannel(server)
     runcommand(server, ['phase', '-r', '.'])
     os.system('hg phase -r . -p')
     runcommand(server, ['phase', '-r', '.'])
 
 def rollback(server):
     readchannel(server)
     runcommand(server, ['phase', '-r', '.', '-p'])
     f = open('a', 'ab')
     f.write('a\n')
     f.close()
     runcommand(server, ['commit', '-Am.'])
     runcommand(server, ['rollback'])
     runcommand(server, ['phase', '-r', '.'])
 
 def branch(server):
     readchannel(server)
     runcommand(server, ['branch'])
     os.system('hg branch foo')
     runcommand(server, ['branch'])
     os.system('hg branch default')
 
 def hgignore(server):
     readchannel(server)
     f = open('.hgignore', 'ab')
     f.write('')
     f.close()
     runcommand(server, ['commit', '-Am.'])
     f = open('ignored-file', 'ab')
     f.write('')
     f.close()
     f = open('.hgignore', 'ab')
     f.write('ignored-file')
     f.close()
     runcommand(server, ['status', '-i', '-u'])
 
 def phasecacheafterstrip(server):
     readchannel(server)
 
     # create new head, 5:731265503d86
     runcommand(server, ['update', '-C', '0'])
     f = open('a', 'ab')
     f.write('a\n')
     f.close()
     runcommand(server, ['commit', '-Am.', 'a'])
     runcommand(server, ['log', '-Gq'])
 
     # make it public; draft marker moves to 4:7966c8e3734d
     runcommand(server, ['phase', '-p', '.'])
     runcommand(server, ['phase', '.'])  # load _phasecache.phaseroots
 
     # strip 1::4 outside server
-    os.system('hg --config extensions.mq= strip 1')
+    os.system('hg -q --config extensions.mq= strip 1')
 
     # shouldn't raise "7966c8e3734d: no node!"
     runcommand(server, ['branches'])
 
 if __name__ == '__main__':
     os.system('hg init')
 
     check(hellomessage)
     check(unknowncommand)
     check(checkruncommand)
     check(inputeof)
     check(serverinput)
     check(cwd)
 
     hgrc = open('.hg/hgrc', 'a')
     hgrc.write('[ui]\nfoo=bar\n')
     hgrc.close()
     check(localhgrc)
     check(hookoutput)
     check(outsidechanges)
     check(bookmarks)
     check(tagscache)
     check(setphase)
     check(rollback)
     check(branch)
     check(hgignore)
     check(phasecacheafterstrip)

tests/test-commandserver.py.out

@@ -1,192 +1,191 b''
 
 testing hellomessage:
 
 o, 'capabilities: getencoding runcommand\nencoding: ***'
  runcommand id
 000000000000 tip
 
 testing unknowncommand:
 
 abort: unknown command unknowncommand
 
 testing checkruncommand:
 
  runcommand 
 Mercurial Distributed SCM
 
 basic commands:
 
  add           add the specified files on the next commit
  annotate      show changeset information by line for each file
  clone         make a copy of an existing repository
  commit        commit the specified files or all outstanding changes
  diff          diff repository (or selected files)
  export        dump the header and diffs for one or more changesets
  forget        forget the specified files on the next commit
  init          create a new repository in the given directory
  log           show revision history of entire repository or files
  merge         merge working directory with another revision
  pull          pull changes from the specified source
  push          push changes to the specified destination
  remove        remove the specified files on the next commit
  serve         start stand-alone webserver
  status        show changed files in the working directory
  summary       summarize working directory state
  update        update working directory (or switch revisions)
 
 use "hg help" for the full list of commands or "hg -v" for details
  runcommand id --quiet
 000000000000
  runcommand id
 000000000000 tip
  runcommand id --config ui.quiet=True
 000000000000
  runcommand id
 000000000000 tip
 
 testing inputeof:
 
 server exit code = 1
 
 testing serverinput:
 
  runcommand import -
 applying patch from stdin
  runcommand log
 changeset:   0:eff892de26ec
 tag:         tip
 user:        test
 date:        Thu Jan 01 00:00:00 1970 +0000
 summary:     1
 
 
 testing cwd:
 
  runcommand --cwd foo st bar
 ? bar
  runcommand st foo/bar
 ? foo/bar
 
 testing localhgrc:
 
  runcommand showconfig
 bundle.mainreporoot=$TESTTMP
 defaults.backout=-d "0 0"
 defaults.commit=-d "0 0"
 defaults.tag=-d "0 0"
 ui.slash=True
 ui.interactive=False
 ui.foo=bar
  runcommand init foo
  runcommand -R foo showconfig ui defaults
 defaults.backout=-d "0 0"
 defaults.commit=-d "0 0"
 defaults.tag=-d "0 0"
 ui.slash=True
 ui.interactive=False
 
 testing hookoutput:
 
  runcommand --config hooks.pre-identify=python:test-commandserver.hook id
 hook talking
 now try to read something: 'some input'
 eff892de26ec tip
 
 testing outsidechanges:
 
  runcommand status
 M a
  runcommand tip
 changeset:   1:d3a0a68be6de
 tag:         tip
 user:        test
 date:        Thu Jan 01 00:00:00 1970 +0000
 summary:     2
 
  runcommand status
 
 testing bookmarks:
 
  runcommand bookmarks
 no bookmarks set
  runcommand bookmarks
    bm1                       1:d3a0a68be6de
    bm2                       1:d3a0a68be6de
  runcommand bookmarks
  * bm1                       1:d3a0a68be6de
    bm2                       1:d3a0a68be6de
  runcommand bookmarks bm3
  runcommand commit -Amm
  runcommand bookmarks
    bm1                       1:d3a0a68be6de
    bm2                       1:d3a0a68be6de
  * bm3                       2:aef17e88f5f0
 
 testing tagscache:
 
  runcommand id -t -r 0
 
  runcommand id -t -r 0
 foo
 
 testing setphase:
 
  runcommand phase -r .
 3: draft
  runcommand phase -r .
 3: public
 
 testing rollback:
 
  runcommand phase -r . -p
 no phases changed
  runcommand commit -Am.
  runcommand rollback
 repository tip rolled back to revision 3 (undo commit)
 working directory now based on revision 3
  runcommand phase -r .
 3: public
 
 testing branch:
 
  runcommand branch
 default
 marked working directory as branch foo
 (branches are permanent and global, did you want a bookmark?)
  runcommand branch
 foo
 marked working directory as branch default
 (branches are permanent and global, did you want a bookmark?)
 
 testing hgignore:
 
  runcommand commit -Am.
 adding .hgignore
  runcommand status -i -u
 I ignored-file
 
 testing phasecacheafterstrip:
 
  runcommand update -C 0
 1 files updated, 0 files merged, 2 files removed, 0 files unresolved
  runcommand commit -Am. a
 created new head
  runcommand log -Gq
 @  5:731265503d86
 |
 | o  4:7966c8e3734d
 | |
 | o  3:b9b85890c400
 | |
 | o  2:aef17e88f5f0
 | |
 | o  1:d3a0a68be6de
 |/
 o  0:eff892de26ec
 
  runcommand phase -p .
  runcommand phase .
 5: public
-saved backup bundle to $TESTTMP/.hg/strip-backup/d3a0a68be6de-backup.hg
  runcommand branches
 default                        1:731265503d86