/brz/remove-bazaar

# Copyright (C) 2005-2010 Canonical Ltd

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

"""Tests for finding and reading the bzr config file[s]."""

# import system imports here

from cStringIO import StringIO

import os

import sys

#import bzrlib specific imports here

from bzrlib import (

    branch,

    bzrdir,

    config,

    diff,

    errors,

    osutils,

    mail_client,

    ui,

    urlutils,

    tests,

    trace,

    transport,

    )

from bzrlib.tests import features

from bzrlib.util.configobj import configobj

sample_long_alias="log -r-15..-1 --line"

sample_config_text = u"""

[DEFAULT]

email=Erik B\u00e5gfors <erik@bagfors.nu>

editor=vim

change_editor=vimdiff -of @new_path @old_path

gpg_signing_command=gnome-gpg

log_format=short

user_global_option=something

[ALIASES]

h=help

ll=""" + sample_long_alias + "\n"

sample_always_signatures = """

[DEFAULT]

check_signatures=ignore

create_signatures=always

"""

sample_ignore_signatures = """

[DEFAULT]

check_signatures=require

create_signatures=never

"""

sample_maybe_signatures = """

[DEFAULT]

check_signatures=ignore

create_signatures=when-required

"""

sample_branches_text = """

[http://www.example.com]

# Top level policy

email=Robert Collins <robertc@example.org>

normal_option = normal

appendpath_option = append

appendpath_option:policy = appendpath

norecurse_option = norecurse

norecurse_option:policy = norecurse

[http://www.example.com/ignoreparent]

# different project: ignore parent dir config

ignore_parents=true

[http://www.example.com/norecurse]

# configuration items that only apply to this dir

recurse=false

normal_option = norecurse

[http://www.example.com/dir]

appendpath_option = normal

[/b/]

check_signatures=require

# test trailing / matching with no children

[/a/]

check_signatures=check-available

gpg_signing_command=false

user_local_option=local

# test trailing / matching

[/a/*]

#subdirs will match but not the parent

[/a/c]

check_signatures=ignore

post_commit=bzrlib.tests.test_config.post_commit

#testing explicit beats globs

"""

class InstrumentedConfigObj(object):

    """A config obj look-enough-alike to record calls made to it."""

    def __contains__(self, thing):

        self._calls.append(('__contains__', thing))

        return False

    def __getitem__(self, key):

        self._calls.append(('__getitem__', key))

        return self

    def __init__(self, input, encoding=None):

        self._calls = [('__init__', input, encoding)]

    def __setitem__(self, key, value):

        self._calls.append(('__setitem__', key, value))

    def __delitem__(self, key):

        self._calls.append(('__delitem__', key))

    def keys(self):

        self._calls.append(('keys',))

        return []

    def write(self, arg):

        self._calls.append(('write',))

    def as_bool(self, value):

        self._calls.append(('as_bool', value))

        return False

    def get_value(self, section, name):

        self._calls.append(('get_value', section, name))

        return None

class FakeBranch(object):

    def __init__(self, base=None, user_id=None):

        if base is None:

            self.base = "http://example.com/branches/demo"

        else:

            self.base = base

        self._transport = self.control_files = \

            FakeControlFilesAndTransport(user_id=user_id)

    def _get_config(self):

        return config.TransportConfig(self._transport, 'branch.conf')

    def lock_write(self):

        pass

    def unlock(self):

        pass

class FakeControlFilesAndTransport(object):

    def __init__(self, user_id=None):

        self.files = {}

        if user_id:

            self.files['email'] = user_id

        self._transport = self

    def get_utf8(self, filename):

        # from LockableFiles

        raise AssertionError("get_utf8 should no longer be used")

    def get(self, filename):

        # from Transport

        try:

            return StringIO(self.files[filename])

        except KeyError:

            raise errors.NoSuchFile(filename)

    def get_bytes(self, filename):

        # from Transport

        try:

            return self.files[filename]

        except KeyError:

            raise errors.NoSuchFile(filename)

    def put(self, filename, fileobj):

        self.files[filename] = fileobj.read()

    def put_file(self, filename, fileobj):

        return self.put(filename, fileobj)

class InstrumentedConfig(config.Config):

    """An instrumented config that supplies stubs for template methods."""

    def __init__(self):

        super(InstrumentedConfig, self).__init__()

        self._calls = []

        self._signatures = config.CHECK_NEVER

    def _get_user_id(self):

        self._calls.append('_get_user_id')

        return "Robert Collins <robert.collins@example.org>"

    def _get_signature_checking(self):

        self._calls.append('_get_signature_checking')

        return self._signatures

    def _get_change_editor(self):

        self._calls.append('_get_change_editor')

        return 'vimdiff -fo @new_path @old_path'

bool_config = """[DEFAULT]

active = true

inactive = false

[UPPERCASE]

active = True

nonactive = False

"""

class TestConfigObj(tests.TestCase):

    def test_get_bool(self):

        co = config.ConfigObj(StringIO(bool_config))

        self.assertIs(co.get_bool('DEFAULT', 'active'), True)

        self.assertIs(co.get_bool('DEFAULT', 'inactive'), False)

        self.assertIs(co.get_bool('UPPERCASE', 'active'), True)

        self.assertIs(co.get_bool('UPPERCASE', 'nonactive'), False)

    def test_hash_sign_in_value(self):

        """

        Before 4.5.0, ConfigObj did not quote # signs in values, so they'd be

        treated as comments when read in again. (#86838)

        """

        co = config.ConfigObj()

        co['test'] = 'foo#bar'

        lines = co.write()

        self.assertEqual(lines, ['test = "foo#bar"'])

        co2 = config.ConfigObj(lines)

        self.assertEqual(co2['test'], 'foo#bar')

erroneous_config = """[section] # line 1

good=good # line 2

[section] # line 3

whocares=notme # line 4

"""

class TestConfigObjErrors(tests.TestCase):

    def test_duplicate_section_name_error_line(self):

        try:

            co = configobj.ConfigObj(StringIO(erroneous_config),

                                     raise_errors=True)

        except config.configobj.DuplicateError, e:

            self.assertEqual(3, e.line_number)

        else:

            self.fail('Error in config file not detected')

class TestConfig(tests.TestCase):

    def test_constructs(self):

        config.Config()

    def test_no_default_editor(self):

        self.assertRaises(NotImplementedError, config.Config().get_editor)

    def test_user_email(self):

        my_config = InstrumentedConfig()

        self.assertEqual('robert.collins@example.org', my_config.user_email())

        self.assertEqual(['_get_user_id'], my_config._calls)

    def test_username(self):

        my_config = InstrumentedConfig()

        self.assertEqual('Robert Collins <robert.collins@example.org>',

                         my_config.username())

        self.assertEqual(['_get_user_id'], my_config._calls)

    def test_signatures_default(self):

        my_config = config.Config()

        self.assertFalse(my_config.signature_needed())

        self.assertEqual(config.CHECK_IF_POSSIBLE,

                         my_config.signature_checking())

        self.assertEqual(config.SIGN_WHEN_REQUIRED,

                         my_config.signing_policy())

    def test_signatures_template_method(self):

        my_config = InstrumentedConfig()

        self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())

        self.assertEqual(['_get_signature_checking'], my_config._calls)

    def test_signatures_template_method_none(self):

        my_config = InstrumentedConfig()

        my_config._signatures = None

        self.assertEqual(config.CHECK_IF_POSSIBLE,

                         my_config.signature_checking())

        self.assertEqual(['_get_signature_checking'], my_config._calls)

    def test_gpg_signing_command_default(self):

        my_config = config.Config()

        self.assertEqual('gpg', my_config.gpg_signing_command())

    def test_get_user_option_default(self):

        my_config = config.Config()

        self.assertEqual(None, my_config.get_user_option('no_option'))

    def test_post_commit_default(self):

        my_config = config.Config()

        self.assertEqual(None, my_config.post_commit())

    def test_log_format_default(self):

        my_config = config.Config()

        self.assertEqual('long', my_config.log_format())

    def test_get_change_editor(self):

        my_config = InstrumentedConfig()

        change_editor = my_config.get_change_editor('old_tree', 'new_tree')

        self.assertEqual(['_get_change_editor'], my_config._calls)

        self.assertIs(diff.DiffFromTool, change_editor.__class__)

        self.assertEqual(['vimdiff', '-fo', '@new_path', '@old_path'],

                         change_editor.command_template)

class TestConfigPath(tests.TestCase):

    def setUp(self):

        super(TestConfigPath, self).setUp()

        os.environ['HOME'] = '/home/bogus'

        os.environ['XDG_CACHE_DIR'] = ''

        if sys.platform == 'win32':

            os.environ['BZR_HOME'] = \

                r'C:\Documents and Settings\bogus\Application Data'

            self.bzr_home = \

                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0'

        else:

            self.bzr_home = '/home/bogus/.bazaar'

    def test_config_dir(self):

        self.assertEqual(config.config_dir(), self.bzr_home)

    def test_config_filename(self):

        self.assertEqual(config.config_filename(),

                         self.bzr_home + '/bazaar.conf')

    def test_locations_config_filename(self):

        self.assertEqual(config.locations_config_filename(),

                         self.bzr_home + '/locations.conf')

    def test_authentication_config_filename(self):

        self.assertEqual(config.authentication_config_filename(),

                         self.bzr_home + '/authentication.conf')

    def test_xdg_cache_dir(self):

        self.assertEqual(config.xdg_cache_dir(),

            '/home/bogus/.cache')

class TestIniConfig(tests.TestCaseInTempDir):

    def make_config_parser(self, s):

        conf = config.IniBasedConfig(_content=StringIO(s.encode('utf-8')))

        return conf, conf._get_parser()

class TestIniConfigBuilding(TestIniConfig):

    def test_contructs(self):

        my_config = config.IniBasedConfig()

    def test_from_fp(self):

        config_file = StringIO(sample_config_text.encode('utf-8'))

        my_config = config.IniBasedConfig(_content=config_file)

        self.assertIsInstance(my_config._get_parser(), configobj.ConfigObj)

    def test_cached(self):

        config_file = StringIO(sample_config_text.encode('utf-8'))

        my_config = config.IniBasedConfig(_content=config_file)

        parser = my_config._get_parser()

        self.failUnless(my_config._get_parser() is parser)

    def _dummy_chown(self, path, uid, gid):

        self.path, self.uid, self.gid = path, uid, gid

    def test_ini_config_ownership(self):

        """Ensure that chown is happening during _write_config_file.

        """

        self.requireFeature(features.chown_feature)

        self.overrideAttr(os, 'chown', self._dummy_chown)

        self.path = self.uid = self.gid = None

        conf = config.IniBasedConfig(file_name='foo.conf')

        conf._write_config_file()

        self.assertEquals(self.path, 'foo.conf')

        self.assertTrue(isinstance(self.uid, int))

        self.assertTrue(isinstance(self.gid, int))

    def test_get_filename_parameter_is_deprecated_(self):

        conf = self.callDeprecated([

            'IniBasedConfig.__init__(get_filename) was deprecated in 2.3.'

            ' Use file_name instead.'],

            config.IniBasedConfig, lambda: 'ini.conf')

        self.assertEqual('ini.conf', conf.file_name)

    def test_get_parser_file_parameter_is_deprecated_(self):

        config_file = StringIO(sample_config_text.encode('utf-8'))

        conf = config.IniBasedConfig(_content=config_file)

        conf = self.callDeprecated([

            'IniBasedConfig._get_parser(file=xxx) was deprecated in 2.3.'

            ' Use IniBasedConfig(_content=xxx) instead.'],

            conf._get_parser, file=config_file)

    def test_cant_save_without_a_file_name(self):

        conf = config.IniBasedConfig()

        self.assertRaises(AssertionError, conf._write_config_file)

class TestGetUserOptionAs(TestIniConfig):

    def test_get_user_option_as_bool(self):

        conf, parser = self.make_config_parser("""

a_true_bool = true

a_false_bool = 0

an_invalid_bool = maybe

a_list = hmm, who knows ? # This is interpreted as a list !

""")

        get_bool = conf.get_user_option_as_bool

        self.assertEqual(True, get_bool('a_true_bool'))

        self.assertEqual(False, get_bool('a_false_bool'))

        warnings = []

        def warning(*args):

            warnings.append(args[0] % args[1:])

        self.overrideAttr(trace, 'warning', warning)

        msg = 'Value "%s" is not a boolean for "%s"'

        self.assertIs(None, get_bool('an_invalid_bool'))

        self.assertEquals(msg % ('maybe', 'an_invalid_bool'), warnings[0])

        warnings = []

        self.assertIs(None, get_bool('not_defined_in_this_config'))

        self.assertEquals([], warnings)

    def test_get_user_option_as_list(self):

        conf, parser = self.make_config_parser("""

a_list = a,b,c

length_1 = 1,

one_item = x

""")

        get_list = conf.get_user_option_as_list

        self.assertEqual(['a', 'b', 'c'], get_list('a_list'))

        self.assertEqual(['1'], get_list('length_1'))

        self.assertEqual('x', conf.get_user_option('one_item'))

        # automatically cast to list

        self.assertEqual(['x'], get_list('one_item'))

class TestSupressWarning(TestIniConfig):

    def make_warnings_config(self, s):

        conf, parser = self.make_config_parser(s)

        return conf.suppress_warning

    def test_suppress_warning_unknown(self):

        suppress_warning = self.make_warnings_config('')

        self.assertEqual(False, suppress_warning('unknown_warning'))

    def test_suppress_warning_known(self):

        suppress_warning = self.make_warnings_config('suppress_warnings=a,b')

        self.assertEqual(False, suppress_warning('c'))

        self.assertEqual(True, suppress_warning('a'))

        self.assertEqual(True, suppress_warning('b'))

class TestGetConfig(tests.TestCase):

    def test_constructs(self):

        my_config = config.GlobalConfig()

    def test_calls_read_filenames(self):

        # replace the class that is constructed, to check its parameters

        oldparserclass = config.ConfigObj

        config.ConfigObj = InstrumentedConfigObj

        my_config = config.GlobalConfig()

        try:

            parser = my_config._get_parser()

        finally:

            config.ConfigObj = oldparserclass

        self.failUnless(isinstance(parser, InstrumentedConfigObj))

        self.assertEqual(parser._calls, [('__init__', config.config_filename(),

                                          'utf-8')])

class TestBranchConfig(tests.TestCaseWithTransport):

    def test_constructs(self):

        branch = FakeBranch()

        my_config = config.BranchConfig(branch)

        self.assertRaises(TypeError, config.BranchConfig)

    def test_get_location_config(self):

        branch = FakeBranch()

        my_config = config.BranchConfig(branch)

        location_config = my_config._get_location_config()

        self.assertEqual(branch.base, location_config.location)

        self.failUnless(location_config is my_config._get_location_config())

    def test_get_config(self):

        """The Branch.get_config method works properly"""

        b = bzrdir.BzrDir.create_standalone_workingtree('.').branch

        my_config = b.get_config()

        self.assertIs(my_config.get_user_option('wacky'), None)

        my_config.set_user_option('wacky', 'unlikely')

        self.assertEqual(my_config.get_user_option('wacky'), 'unlikely')

        # Ensure we get the same thing if we start again

        b2 = branch.Branch.open('.')

        my_config2 = b2.get_config()

        self.assertEqual(my_config2.get_user_option('wacky'), 'unlikely')

    def test_has_explicit_nickname(self):

        b = self.make_branch('.')

        self.assertFalse(b.get_config().has_explicit_nickname())

        b.nick = 'foo'

        self.assertTrue(b.get_config().has_explicit_nickname())

    def test_config_url(self):

        """The Branch.get_config will use section that uses a local url"""

        branch = self.make_branch('branch')

        self.assertEqual('branch', branch.nick)

        locations = config.locations_config_filename()

        config.ensure_config_dir_exists()

        local_url = urlutils.local_path_to_url('branch')

        open(locations, 'wb').write('[%s]\nnickname = foobar'

                                    % (local_url,))

        self.assertEqual('foobar', branch.nick)

    def test_config_local_path(self):

        """The Branch.get_config will use a local system path"""

        branch = self.make_branch('branch')

        self.assertEqual('branch', branch.nick)

        locations = config.locations_config_filename()

        config.ensure_config_dir_exists()

        open(locations, 'wb').write('[%s/branch]\nnickname = barry'

                                    % (osutils.getcwd().encode('utf8'),))

        self.assertEqual('barry', branch.nick)

    def test_config_creates_local(self):

        """Creating a new entry in config uses a local path."""

        branch = self.make_branch('branch', format='knit')

        branch.set_push_location('http://foobar')

        locations = config.locations_config_filename()

        local_path = osutils.getcwd().encode('utf8')

        # Surprisingly ConfigObj doesn't create a trailing newline

        self.check_file_contents(locations,

                                 '[%s/branch]\n'

                                 'push_location = http://foobar\n'

                                 'push_location:policy = norecurse\n'

                                 % (local_path,))

    def test_autonick_urlencoded(self):

        b = self.make_branch('!repo')

        self.assertEqual('!repo', b.get_config().get_nickname())

    def test_warn_if_masked(self):

        _warning = trace.warning

        warnings = []

        def warning(*args):

            warnings.append(args[0] % args[1:])

        def set_option(store, warn_masked=True):

            warnings[:] = []

            conf.set_user_option('example_option', repr(store), store=store,

                                 warn_masked=warn_masked)

        def assertWarning(warning):

            if warning is None:

                self.assertEqual(0, len(warnings))

            else:

                self.assertEqual(1, len(warnings))

                self.assertEqual(warning, warnings[0])

        trace.warning = warning

        try:

            branch = self.make_branch('.')

            conf = branch.get_config()

            set_option(config.STORE_GLOBAL)

            assertWarning(None)

            set_option(config.STORE_BRANCH)

            assertWarning(None)

            set_option(config.STORE_GLOBAL)

            assertWarning('Value "4" is masked by "3" from branch.conf')

            set_option(config.STORE_GLOBAL, warn_masked=False)

            assertWarning(None)

            set_option(config.STORE_LOCATION)

            assertWarning(None)

            set_option(config.STORE_BRANCH)

            assertWarning('Value "3" is masked by "0" from locations.conf')

            set_option(config.STORE_BRANCH, warn_masked=False)

            assertWarning(None)

        finally:

            trace.warning = _warning

class TestGlobalConfigItems(tests.TestCase):

    def test_user_id(self):

        config_file = StringIO(sample_config_text.encode('utf-8'))

        my_config = config.GlobalConfig(_content=config_file)

        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",

                         my_config._get_user_id())

    def test_absent_user_id(self):

        config_file = StringIO("")

        my_config = config.GlobalConfig(_content=config_file)

        self.assertEqual(None, my_config._get_user_id())

    def test_configured_editor(self):

        config_file = StringIO(sample_config_text.encode('utf-8'))

        my_config = config.GlobalConfig(_content=config_file)

        self.assertEqual("vim", my_config.get_editor())

    def test_signatures_always(self):

        config_file = StringIO(sample_always_signatures)

        my_config = config.GlobalConfig(_content=config_file)

        self.assertEqual(config.CHECK_NEVER,

                         my_config.signature_checking())

        self.assertEqual(config.SIGN_ALWAYS,

                         my_config.signing_policy())

        self.assertEqual(True, my_config.signature_needed())

    def test_signatures_if_possible(self):

        config_file = StringIO(sample_maybe_signatures)

        my_config = config.GlobalConfig(_content=config_file)

        self.assertEqual(config.CHECK_NEVER,