# 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))