annotate tests/test-trusted.py @ 45769:b4c193509cd0

rebase: use hard-coded template for one-line commit description

This is to prepare for making making the one-line summary
customizable. The template ended up pretty complicated because of the
conditional output of "(<bookmarks etc>)". Maybe we can simplify the
template later.

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

# Since it's not easy to write a test that portably deals
# with files from different users/groups, we cheat a bit by
# monkey-patching some functions in the util module

from __future__ import absolute_import, print_function

import os
import sys

from mercurial import (
    error,
    pycompat,
    ui as uimod,
    util,
)
from mercurial.utils import stringutil

hgrc = os.environ['HGRCPATH']
f = open(hgrc, 'rb')
basehgrc = f.read()
f.close()


def _maybesysstr(v):
    if isinstance(v, bytes):
        return pycompat.sysstr(v)
    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,
):
    # user, group => owners of the file
    # tusers, tgroups => trusted users/groups
    # cuser, cgroup => user/group of the current process

    # write a global hgrc with the list of trusted users/groups and
    # some setting so that we can be sure it was read
    f = open(hgrc, 'wb')
    f.write(basehgrc)
    f.write(b'\n[paths]\n')
    f.write(b'global = /some/path\n\n')

    if tusers or tgroups:
        f.write(b'[trusted]\n')
        if tusers:
            f.write(b'users = %s\n' % b', '.join(tusers))
        if tgroups:
            f.write(b'groups = %s\n' % b', '.join(tgroups))
    f.close()

    # override the functions that give names to uids and gids
    def username(uid=None):
        if uid is None:
            return cuser
        return user

    util.username = username

    def groupname(gid=None):
        if gid is None:
            return b'bar'
        return group

    util.groupname = groupname

    def isowner(st):
        return user == cuser

    util.isowner = isowner

    # try to read everything
    # print '# File belongs to user %s, group %s' % (user, group)
    # print '# trusted users = %s; trusted groups = %s' % (tusers, tgroups)
    kind = (b'different', b'same')
    who = (b'', b'user', b'group', b'user and the group')
    trusted = who[(user in tusers) + 2 * (group in tgroups)]
    if trusted:
        trusted = b', but we trust the ' + trusted
    bprint(
        b'# %s user, %s group%s'
        % (kind[user == cuser], kind[group == cgroup], trusted)
    )

    u = uimod.ui.load()
    # disable the configuration registration warning
    #
    # 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
    # config.
    u.setconfig(b'devel', b'warn-config-unknown', False, b'test')
    u.setconfig(b'devel', b'all-warnings', False, b'test')
    u.setconfig(b'ui', b'debug', pycompat.bytestr(bool(debug)))
    u.setconfig(b'ui', b'report_untrusted', pycompat.bytestr(bool(report)))
    u.readconfig(b'.hg/hgrc')
    if silent:
        return u
    bprint(b'trusted')
    for name, path in u.configitems(b'paths'):
        bprint(b'   ', name, b'=', util.pconvert(path))
    bprint(b'untrusted')
    for name, path in u.configitems(b'paths', untrusted=True):
        bprint(b'.', end=b' ')
        u.config(b'paths', name)  # warning with debug=True
        bprint(b'.', end=b' ')
        u.config(b'paths', name, untrusted=True)  # no warnings
        bprint(name, b'=', util.pconvert(path))
    print()

    return u


os.mkdir(b'repo')
os.chdir(b'repo')
os.mkdir(b'.hg')
f = open(b'.hg/hgrc', 'wb')
f.write(b'[paths]\n')
f.write(b'local = /another/path\n\n')
f.close()

# print '# Everything is run by user foo, group bar\n'

# same user, same group
testui()
# same user, different group
testui(group=b'def')
# different user, same group
testui(user=b'abc')
# ... but we trust the group
testui(user=b'abc', tgroups=[b'bar'])
# different user, different group
testui(user=b'abc', group=b'def')
# ... but we trust the user
testui(user=b'abc', group=b'def', tusers=[b'abc'])
# ... but we trust the group
testui(user=b'abc', group=b'def', tgroups=[b'def'])
# ... but we trust the user and the group
testui(user=b'abc', group=b'def', tusers=[b'abc'], tgroups=[b'def'])
# ... but we trust all users
bprint(b'# we trust all users')
testui(user=b'abc', group=b'def', tusers=[b'*'])
# ... but we trust all groups
bprint(b'# we trust all groups')
testui(user=b'abc', group=b'def', tgroups=[b'*'])
# ... but we trust the whole universe
bprint(b'# we trust all users and groups')
testui(user=b'abc', group=b'def', tusers=[b'*'], tgroups=[b'*'])
# ... check that users and groups are in different namespaces
bprint(b"# we don't get confused by users and groups with the same name")
testui(user=b'abc', group=b'def', tusers=[b'def'], tgroups=[b'abc'])
# ... lists of user names work
bprint(b"# list of user names")
testui(
    user=b'abc',
    group=b'def',
    tusers=[b'foo', b'xyz', b'abc', b'bleh'],
    tgroups=[b'bar', b'baz', b'qux'],
)
# ... lists of group names work
bprint(b"# list of group names")
testui(
    user=b'abc',
    group=b'def',
    tusers=[b'foo', b'xyz', b'bleh'],
    tgroups=[b'bar', b'def', b'baz', b'qux'],
)

bprint(b"# Can't figure out the name of the user running this process")
testui(user=b'abc', group=b'def', cuser=None)

bprint(b"# prints debug warnings")
u = testui(user=b'abc', group=b'def', cuser=b'foo', debug=True)

bprint(b"# report_untrusted enabled without debug hides warnings")
u = testui(user=b'abc', group=b'def', cuser=b'foo', report=False)

bprint(b"# report_untrusted enabled with debug shows warnings")
u = testui(user=b'abc', group=b'def', cuser=b'foo', debug=True, report=False)

bprint(b"# ui.readconfig sections")
filename = b'foobar'
f = open(filename, 'wb')
f.write(b'[foobar]\n')
f.write(b'baz = quux\n')
f.close()
u.readconfig(filename, sections=[b'foobar'])
bprint(u.config(b'foobar', b'baz'))

print()
bprint(b"# read trusted, untrusted, new ui, trusted")
u = uimod.ui.load()
# disable the configuration registration warning
#
# 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
# config.
u.setconfig(b'devel', b'warn-config-unknown', False, b'test')
u.setconfig(b'devel', b'all-warnings', False, b'test')
u.setconfig(b'ui', b'debug', b'on')
u.readconfig(filename)
u2 = u.copy()


def username(uid=None):
    return b'foo'


util.username = username
u2.readconfig(b'.hg/hgrc')
bprint(b'trusted:')
bprint(u2.config(b'foobar', b'baz'))
bprint(b'untrusted:')
bprint(u2.config(b'foobar', b'baz', untrusted=True))

print()
bprint(b"# error handling")


def assertraises(f, exc=error.Abort):
    try:
        f()
    except exc as inst:
        bprint(b'raised', inst.__class__.__name__)
    else:
        bprint(b'no exception?!')


bprint(b"# file doesn't exist")
os.unlink(b'.hg/hgrc')
assert not os.path.exists(b'.hg/hgrc')
testui(debug=True, silent=True)
testui(user=b'abc', group=b'def', debug=True, silent=True)

print()
bprint(b"# parse error")
f = open(b'.hg/hgrc', 'wb')
f.write(b'foo')
f.close()

# This is a hack to remove b'' prefixes from ParseError.__bytes__ on
# Python 3.
def normalizeparseerror(e):
    if pycompat.ispy3:
        args = [a.decode('utf-8') for a in e.args]
    else:
        args = e.args

    return error.ParseError(*args)


try:
    testui(user=b'abc', group=b'def', silent=True)
except error.ParseError as inst:
    bprint(normalizeparseerror(inst))

try:
    testui(debug=True, silent=True)
except error.ParseError as inst:
    bprint(normalizeparseerror(inst))

print()
bprint(b'# access typed information')
with open(b'.hg/hgrc', 'wb') as f:
    f.write(
        b'''\
[foo]
sub=main
sub:one=one
sub:two=two
path=monty/python
bool=true
int=42
bytes=81mb
list=spam,ham,eggs
'''
    )
u = testui(user=b'abc', group=b'def', cuser=b'foo', silent=True)


def configpath(section, name, default=None, untrusted=False):
    path = u.configpath(section, name, default, untrusted)
    if path is None:
        return None
    return util.pconvert(path)


bprint(b'# suboptions, trusted and untrusted')
trusted = u.configsuboptions(b'foo', b'sub')
untrusted = u.configsuboptions(b'foo', b'sub', untrusted=True)
bprint(
    (trusted[0], sorted(trusted[1].items())),
    (untrusted[0], sorted(untrusted[1].items())),
)
bprint(b'# path, trusted and untrusted')
bprint(configpath(b'foo', b'path'), configpath(b'foo', b'path', untrusted=True))
bprint(b'# bool, trusted and untrusted')
bprint(
    u.configbool(b'foo', b'bool'), u.configbool(b'foo', b'bool', untrusted=True)
)
bprint(b'# int, trusted and untrusted')
bprint(
    u.configint(b'foo', b'int', 0),
    u.configint(b'foo', b'int', 0, untrusted=True),
)
bprint(b'# bytes, trusted and untrusted')
bprint(
    u.configbytes(b'foo', b'bytes', 0),
    u.configbytes(b'foo', b'bytes', 0, untrusted=True),
)
bprint(b'# list, trusted and untrusted')
bprint(
    u.configlist(b'foo', b'list', []),
    u.configlist(b'foo', b'list', [], untrusted=True),
)