This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5685

py3: almost fix test-trusted.py
ClosedPublic

Authored by durin42 on Jan 24 2019, 3:04 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG73ccba60aaa1: py3: almost fix test-trusted.py
Summary

The test now only fails due to output format changes on the repr of
mercurial.error.ParseError. I'm not really sure how to approach that
for now.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

durin42 created this revision.Jan 24 2019, 3:04 PM
pulkit added a subscriber: pulkit.Jan 24 2019, 3:12 PM
pulkit added inline comments.
tests/test-trusted.py
25

We can drop this if pycompat.ispy3.

durin42 updated this revision to Diff 13426.Jan 24 2019, 3:24 PM
Closed by commit rHG73ccba60aaa1: py3: almost fix test-trusted.py (authored by durin42). · Explain WhyJan 25 2019, 5:43 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mtests/test-trusted.py (255 lines)
Mtests/test-trusted.py.out (4 lines)

Diff 13440

tests/test-trusted.py

# Since it's not easy to write a test that portably deals # Since it's not easy to write a test that portably deals
# with files from different users/groups, we cheat a bit by # with files from different users/groups, we cheat a bit by
# monkey-patching some functions in the util module # monkey-patching some functions in the util module
from __future__ import absolute_import, print_function from __future__ import absolute_import, print_function
import os import os
import sys
from mercurial import ( from mercurial import (
error, error,
pycompat,
ui as uimod, ui as uimod,
util, util,
) )
from mercurial.utils import stringutil
hgrc = os.environ['HGRCPATH'] hgrc = os.environ['HGRCPATH']
f = open(hgrc) f = open(hgrc, 'rb')
basehgrc = f.read() basehgrc = f.read()
f.close() f.close()
def testui(user='foo', group='bar', tusers=(), tgroups=(), def _maybesysstr(v):
cuser='foo', cgroup='bar', debug=False, silent=False, if isinstance(v, bytes):
return pycompat.sysstr(v)
pulkitUnsubmitted
Not Done

We can drop this if pycompat.ispy3.

pulkit: We can drop this `if pycompat.ispy3`.
return pycompat.sysstr(stringutil.pprint(v))
def bprint(*args, **kwargs):
print(*[_maybesysstr(a) for a in args],
**{k: _maybesysstr(v) for k, v in kwargs.items()})
# avoid awkward interleaving with ui object's output
sys.stdout.flush()
def testui(user=b'foo', group=b'bar', tusers=(), tgroups=(),
cuser=b'foo', cgroup=b'bar', debug=False, silent=False,
report=True): report=True):
# user, group => owners of the file # user, group => owners of the file
# tusers, tgroups => trusted users/groups # tusers, tgroups => trusted users/groups
# cuser, cgroup => user/group of the current process # cuser, cgroup => user/group of the current process
# write a global hgrc with the list of trusted users/groups and # write a global hgrc with the list of trusted users/groups and
# some setting so that we can be sure it was read # some setting so that we can be sure it was read
f = open(hgrc, 'w') f = open(hgrc, 'wb')
f.write(basehgrc) f.write(basehgrc)
f.write('\n[paths]\n') f.write(b'\n[paths]\n')
f.write('global = /some/path\n\n') f.write(b'global = /some/path\n\n')
if tusers or tgroups: if tusers or tgroups:
f.write('[trusted]\n') f.write(b'[trusted]\n')
if tusers: if tusers:
f.write('users = %s\n' % ', '.join(tusers)) f.write(b'users = %s\n' % b', '.join(tusers))
if tgroups: if tgroups:
f.write('groups = %s\n' % ', '.join(tgroups)) f.write(b'groups = %s\n' % b', '.join(tgroups))
f.close() f.close()
# override the functions that give names to uids and gids # override the functions that give names to uids and gids
def username(uid=None): def username(uid=None):
if uid is None: if uid is None:
return cuser return cuser
return user return user
util.username = username util.username = username
def groupname(gid=None): def groupname(gid=None):
if gid is None: if gid is None:
return 'bar' return b'bar'
return group return group
util.groupname = groupname util.groupname = groupname
def isowner(st): def isowner(st):
return user == cuser return user == cuser
util.isowner = isowner util.isowner = isowner
# try to read everything # try to read everything
#print '# File belongs to user %s, group %s' % (user, group) #print '# File belongs to user %s, group %s' % (user, group)
#print '# trusted users = %s; trusted groups = %s' % (tusers, tgroups) #print '# trusted users = %s; trusted groups = %s' % (tusers, tgroups)
kind = ('different', 'same') kind = (b'different', b'same')
who = ('', 'user', 'group', 'user and the group') who = (b'', b'user', b'group', b'user and the group')
trusted = who[(user in tusers) + 2*(group in tgroups)] trusted = who[(user in tusers) + 2*(group in tgroups)]
if trusted: if trusted:
trusted = ', but we trust the ' + trusted trusted = b', but we trust the ' + trusted
print('# %s user, %s group%s' % (kind[user == cuser], kind[group == cgroup], bprint(b'# %s user, %s group%s' % (kind[user == cuser],
kind[group == cgroup],
trusted)) trusted))
u = uimod.ui.load() u = uimod.ui.load()
# disable the configuration registration warning # disable the configuration registration warning
# #
# the purpose of this test is to check the old behavior, not to validate the # the purpose of this test is to check the old behavior, not to validate the
# behavior from registered item. so we silent warning related to unregisted # behavior from registered item. so we silent warning related to unregisted
# config. # config.
u.setconfig('devel', 'warn-config-unknown', False, 'test') u.setconfig(b'devel', b'warn-config-unknown', False, b'test')
u.setconfig('devel', 'all-warnings', False, 'test') u.setconfig(b'devel', b'all-warnings', False, b'test')
u.setconfig('ui', 'debug', str(bool(debug))) u.setconfig(b'ui', b'debug', pycompat.bytestr(bool(debug)))
u.setconfig('ui', 'report_untrusted', str(bool(report))) u.setconfig(b'ui', b'report_untrusted', pycompat.bytestr(bool(report)))
u.readconfig('.hg/hgrc') u.readconfig(b'.hg/hgrc')
if silent: if silent:
return u return u
print('trusted') bprint(b'trusted')
for name, path in u.configitems('paths'): for name, path in u.configitems(b'paths'):
print(' ', name, '=', util.pconvert(path)) bprint(b' ', name, b'=', util.pconvert(path))
print('untrusted') bprint(b'untrusted')
for name, path in u.configitems('paths', untrusted=True): for name, path in u.configitems(b'paths', untrusted=True):
print('.', end=' ') bprint(b'.', end=b' ')
u.config('paths', name) # warning with debug=True u.config(b'paths', name) # warning with debug=True
print('.', end=' ') bprint(b'.', end=b' ')
u.config('paths', name, untrusted=True) # no warnings u.config(b'paths', name, untrusted=True) # no warnings
print(name, '=', util.pconvert(path)) bprint(name, b'=', util.pconvert(path))
print() print()
return u return u
os.mkdir('repo') os.mkdir(b'repo')
os.chdir('repo') os.chdir(b'repo')
os.mkdir('.hg') os.mkdir(b'.hg')
f = open('.hg/hgrc', 'w') f = open(b'.hg/hgrc', 'wb')
f.write('[paths]\n') f.write(b'[paths]\n')
f.write('local = /another/path\n\n') f.write(b'local = /another/path\n\n')
f.close() f.close()
#print '# Everything is run by user foo, group bar\n' #print '# Everything is run by user foo, group bar\n'
# same user, same group # same user, same group
testui() testui()
# same user, different group # same user, different group
testui(group='def') testui(group=b'def')
# different user, same group # different user, same group
testui(user='abc') testui(user=b'abc')
# ... but we trust the group # ... but we trust the group
testui(user='abc', tgroups=['bar']) testui(user=b'abc', tgroups=[b'bar'])
# different user, different group # different user, different group
testui(user='abc', group='def') testui(user=b'abc', group=b'def')
# ... but we trust the user # ... but we trust the user
testui(user='abc', group='def', tusers=['abc']) testui(user=b'abc', group=b'def', tusers=[b'abc'])
# ... but we trust the group # ... but we trust the group
testui(user='abc', group='def', tgroups=['def']) testui(user=b'abc', group=b'def', tgroups=[b'def'])
# ... but we trust the user and the group # ... but we trust the user and the group
testui(user='abc', group='def', tusers=['abc'], tgroups=['def']) testui(user=b'abc', group=b'def', tusers=[b'abc'], tgroups=[b'def'])
# ... but we trust all users # ... but we trust all users
print('# we trust all users') bprint(b'# we trust all users')
testui(user='abc', group='def', tusers=['*']) testui(user=b'abc', group=b'def', tusers=[b'*'])
# ... but we trust all groups # ... but we trust all groups
print('# we trust all groups') bprint(b'# we trust all groups')
testui(user='abc', group='def', tgroups=['*']) testui(user=b'abc', group=b'def', tgroups=[b'*'])
# ... but we trust the whole universe # ... but we trust the whole universe
print('# we trust all users and groups') bprint(b'# we trust all users and groups')
testui(user='abc', group='def', tusers=['*'], tgroups=['*']) testui(user=b'abc', group=b'def', tusers=[b'*'], tgroups=[b'*'])
# ... check that users and groups are in different namespaces # ... check that users and groups are in different namespaces
print("# we don't get confused by users and groups with the same name") bprint(b"# we don't get confused by users and groups with the same name")
testui(user='abc', group='def', tusers=['def'], tgroups=['abc']) testui(user=b'abc', group=b'def', tusers=[b'def'], tgroups=[b'abc'])
# ... lists of user names work # ... lists of user names work
print("# list of user names") bprint(b"# list of user names")
testui(user='abc', group='def', tusers=['foo', 'xyz', 'abc', 'bleh'], testui(user=b'abc', group=b'def', tusers=[b'foo', b'xyz', b'abc', b'bleh'],
tgroups=['bar', 'baz', 'qux']) tgroups=[b'bar', b'baz', b'qux'])
# ... lists of group names work # ... lists of group names work
print("# list of group names") bprint(b"# list of group names")
testui(user='abc', group='def', tusers=['foo', 'xyz', 'bleh'], testui(user=b'abc', group=b'def', tusers=[b'foo', b'xyz', b'bleh'],
tgroups=['bar', 'def', 'baz', 'qux']) tgroups=[b'bar', b'def', b'baz', b'qux'])
print("# Can't figure out the name of the user running this process") bprint(b"# Can't figure out the name of the user running this process")
testui(user='abc', group='def', cuser=None) testui(user=b'abc', group=b'def', cuser=None)
print("# prints debug warnings") bprint(b"# prints debug warnings")
u = testui(user='abc', group='def', cuser='foo', debug=True) u = testui(user=b'abc', group=b'def', cuser=b'foo', debug=True)
print("# report_untrusted enabled without debug hides warnings") bprint(b"# report_untrusted enabled without debug hides warnings")
u = testui(user='abc', group='def', cuser='foo', report=False) u = testui(user=b'abc', group=b'def', cuser=b'foo', report=False)
print("# report_untrusted enabled with debug shows warnings") bprint(b"# report_untrusted enabled with debug shows warnings")
u = testui(user='abc', group='def', cuser='foo', debug=True, report=False) u = testui(user=b'abc', group=b'def', cuser=b'foo', debug=True, report=False)
print("# ui.readconfig sections") bprint(b"# ui.readconfig sections")
filename = 'foobar' filename = b'foobar'
f = open(filename, 'w') f = open(filename, 'wb')
f.write('[foobar]\n') f.write(b'[foobar]\n')
f.write('baz = quux\n') f.write(b'baz = quux\n')
f.close() f.close()
u.readconfig(filename, sections=['foobar']) u.readconfig(filename, sections=[b'foobar'])
print(u.config('foobar', 'baz')) bprint(u.config(b'foobar', b'baz'))
print() print()
print("# read trusted, untrusted, new ui, trusted") bprint(b"# read trusted, untrusted, new ui, trusted")
u = uimod.ui.load() u = uimod.ui.load()
# disable the configuration registration warning # disable the configuration registration warning
# #
# the purpose of this test is to check the old behavior, not to validate the # the purpose of this test is to check the old behavior, not to validate the
# behavior from registered item. so we silent warning related to unregisted # behavior from registered item. so we silent warning related to unregisted
# config. # config.
u.setconfig('devel', 'warn-config-unknown', False, 'test') u.setconfig(b'devel', b'warn-config-unknown', False, b'test')
u.setconfig('devel', 'all-warnings', False, 'test') u.setconfig(b'devel', b'all-warnings', False, b'test')
u.setconfig('ui', 'debug', 'on') u.setconfig(b'ui', b'debug', b'on')
u.readconfig(filename) u.readconfig(filename)
u2 = u.copy() u2 = u.copy()
def username(uid=None): def username(uid=None):
return 'foo' return b'foo'
util.username = username util.username = username
u2.readconfig('.hg/hgrc') u2.readconfig(b'.hg/hgrc')
print('trusted:') bprint(b'trusted:')
print(u2.config('foobar', 'baz')) bprint(u2.config(b'foobar', b'baz'))
print('untrusted:') bprint(b'untrusted:')
print(u2.config('foobar', 'baz', untrusted=True)) bprint(u2.config(b'foobar', b'baz', untrusted=True))
print() print()
print("# error handling") bprint(b"# error handling")
def assertraises(f, exc=error.Abort): def assertraises(f, exc=error.Abort):
try: try:
f() f()
except exc as inst: except exc as inst:
print('raised', inst.__class__.__name__) bprint(b'raised', inst.__class__.__name__)
else: else:
print('no exception?!') bprint(b'no exception?!')
print("# file doesn't exist") bprint(b"# file doesn't exist")
os.unlink('.hg/hgrc') os.unlink(b'.hg/hgrc')
assert not os.path.exists('.hg/hgrc') assert not os.path.exists(b'.hg/hgrc')
testui(debug=True, silent=True) testui(debug=True, silent=True)
testui(user='abc', group='def', debug=True, silent=True) testui(user=b'abc', group=b'def', debug=True, silent=True)
print() print()
print("# parse error") bprint(b"# parse error")
f = open('.hg/hgrc', 'w') f = open(b'.hg/hgrc', 'wb')
f.write('foo') f.write(b'foo')
f.close() f.close()
try: try:
testui(user='abc', group='def', silent=True) testui(user=b'abc', group=b'def', silent=True)
except error.ParseError as inst: except error.ParseError as inst:
print(inst) bprint(inst)
try: try:
testui(debug=True, silent=True) testui(debug=True, silent=True)
except error.ParseError as inst: except error.ParseError as inst:
print(inst) bprint(inst)
print() print()
print('# access typed information') bprint(b'# access typed information')
with open('.hg/hgrc', 'w') as f: with open(b'.hg/hgrc', 'wb') as f:
f.write('''\ f.write(b'''\
[foo] [foo]
sub=main sub=main
sub:one=one sub:one=one
sub:two=two sub:two=two
path=monty/python path=monty/python
bool=true bool=true
int=42 int=42
bytes=81mb bytes=81mb
list=spam,ham,eggs list=spam,ham,eggs
''') ''')
u = testui(user='abc', group='def', cuser='foo', silent=True) u = testui(user=b'abc', group=b'def', cuser=b'foo', silent=True)
def configpath(section, name, default=None, untrusted=False): def configpath(section, name, default=None, untrusted=False):
path = u.configpath(section, name, default, untrusted) path = u.configpath(section, name, default, untrusted)
if path is None: if path is None:
return None return None
return util.pconvert(path) return util.pconvert(path)
print('# suboptions, trusted and untrusted') bprint(b'# suboptions, trusted and untrusted')
trusted = u.configsuboptions('foo', 'sub') trusted = u.configsuboptions(b'foo', b'sub')
untrusted = u.configsuboptions('foo', 'sub', untrusted=True) untrusted = u.configsuboptions(b'foo', b'sub', untrusted=True)
print( bprint(
(trusted[0], sorted(trusted[1].items())), (trusted[0], sorted(trusted[1].items())),
(untrusted[0], sorted(untrusted[1].items()))) (untrusted[0], sorted(untrusted[1].items())))
print('# path, trusted and untrusted') bprint(b'# path, trusted and untrusted')
print(configpath('foo', 'path'), configpath('foo', 'path', untrusted=True)) bprint(configpath(b'foo', b'path'), configpath(b'foo', b'path', untrusted=True))
print('# bool, trusted and untrusted') bprint(b'# bool, trusted and untrusted')
print(u.configbool('foo', 'bool'), u.configbool('foo', 'bool', untrusted=True)) bprint(u.configbool(b'foo', b'bool'),
print('# int, trusted and untrusted') u.configbool(b'foo', b'bool', untrusted=True))
print( bprint(b'# int, trusted and untrusted')
u.configint('foo', 'int', 0), bprint(
u.configint('foo', 'int', 0, untrusted=True)) u.configint(b'foo', b'int', 0),
print('# bytes, trusted and untrusted') u.configint(b'foo', b'int', 0, untrusted=True))
print( bprint(b'# bytes, trusted and untrusted')
u.configbytes('foo', 'bytes', 0), bprint(
u.configbytes('foo', 'bytes', 0, untrusted=True)) u.configbytes(b'foo', b'bytes', 0),
print('# list, trusted and untrusted') u.configbytes(b'foo', b'bytes', 0, untrusted=True))
print( bprint(b'# list, trusted and untrusted')
u.configlist('foo', 'list', []), bprint(
u.configlist('foo', 'list', [], untrusted=True)) u.configlist(b'foo', b'list', []),
u.configlist(b'foo', b'list', [], untrusted=True))

tests/test-trusted.py.out

# error handling # error handling
# file doesn't exist # file doesn't exist
# same user, same group # same user, same group
# different user, different group # different user, different group
# parse error # parse error
# different user, different group # different user, different group
not trusting file .hg/hgrc from untrusted user abc, group def not trusting file .hg/hgrc from untrusted user abc, group def
('foo', '.hg/hgrc:1') ParseError('foo', '.hg/hgrc:1')
# same user, same group # same user, same group
('foo', '.hg/hgrc:1') ParseError('foo', '.hg/hgrc:1')
# access typed information # access typed information
# different user, different group # different user, different group
not trusting file .hg/hgrc from untrusted user abc, group def not trusting file .hg/hgrc from untrusted user abc, group def
# suboptions, trusted and untrusted # suboptions, trusted and untrusted
(None, []) ('main', [('one', 'one'), ('two', 'two')]) (None, []) ('main', [('one', 'one'), ('two', 'two')])
# path, trusted and untrusted # path, trusted and untrusted
None .hg/monty/python None .hg/monty/python
# bool, trusted and untrusted # bool, trusted and untrusted
False True False True
# int, trusted and untrusted # int, trusted and untrusted
0 42 0 42
# bytes, trusted and untrusted # bytes, trusted and untrusted
0 84934656 0 84934656
# list, trusted and untrusted # list, trusted and untrusted
[] ['spam', 'ham', 'eggs'] [] ['spam', 'ham', 'eggs']