# Copyright (C) 2005-2014, 2016 Canonical Ltd
# Copyright (C) 2019 Breezy developers
#
# 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 deriving user configuration from system environment."""

import os
import sys

from .. import (
    bedding,
    osutils,
    tests,
    )


def override_whoami(test):
    test.overrideEnv('EMAIL', None)
    test.overrideEnv('BRZ_EMAIL', None)
    # Also, make sure that it's not inferred from mailname.
    test.overrideAttr(bedding, '_auto_user_id', lambda: (None, None))


class TestConfigPath(tests.TestCase):

    def setUp(self):
        super(TestConfigPath, self).setUp()
        self.overrideEnv('HOME', '/home/bogus')
        self.overrideEnv('XDG_CACHE_HOME', '')
        if sys.platform == 'win32':
            self.overrideEnv(
                'BRZ_HOME',
                r'C:\Documents and Settings\bogus\Application Data')
            self.brz_home = \
                'C:/Documents and Settings/bogus/Application Data/breezy'
        else:
            self.brz_home = '/home/bogus/.config/breezy'

    def test_config_dir(self):
        self.assertEqual(bedding.config_dir(), self.brz_home)

    def test_config_dir_is_unicode(self):
        self.assertIsInstance(bedding.config_dir(), str)

    def test_config_path(self):
        self.assertEqual(bedding.config_path(),
                         self.brz_home + '/breezy.conf')

    def test_locations_config_path(self):
        self.assertEqual(bedding.locations_config_path(),
                         self.brz_home + '/locations.conf')

    def test_authentication_config_path(self):
        self.assertEqual(bedding.authentication_config_path(),
                         self.brz_home + '/authentication.conf')


class TestConfigPathFallback(tests.TestCaseInTempDir):

    def setUp(self):
        super(TestConfigPathFallback, self).setUp()
        self.overrideEnv('HOME', self.test_dir)
        self.overrideEnv('XDG_CACHE_HOME', '')
        self.bzr_home = os.path.join(self.test_dir, '.bazaar')
        os.mkdir(self.bzr_home)

    def test_config_dir(self):
        self.assertEqual(bedding.config_dir(), self.bzr_home)

    def test_config_dir_is_unicode(self):
        self.assertIsInstance(bedding.config_dir(), str)

    def test_config_path(self):
        self.assertEqual(bedding.config_path(),
                         self.bzr_home + '/bazaar.conf')

    def test_locations_config_path(self):
        self.assertEqual(bedding.locations_config_path(),
                         self.bzr_home + '/locations.conf')

    def test_authentication_config_path(self):
        self.assertEqual(bedding.authentication_config_path(),
                         self.bzr_home + '/authentication.conf')


class TestXDGConfigDir(tests.TestCaseInTempDir):
    # must be in temp dir because config tests for the existence of the bazaar
    # subdirectory of $XDG_CONFIG_HOME

    def setUp(self):
        if sys.platform == 'win32':
            raise tests.TestNotApplicable(
                'XDG config dir not used on this platform')
        super(TestXDGConfigDir, self).setUp()
        self.overrideEnv('HOME', self.test_home_dir)
        # BRZ_HOME overrides everything we want to test so unset it.
        self.overrideEnv('BRZ_HOME', None)

    def test_xdg_config_dir_exists(self):
        """When ~/.config/bazaar exists, use it as the config dir."""
        newdir = osutils.pathjoin(self.test_home_dir, '.config', 'bazaar')
        os.makedirs(newdir)
        self.assertEqual(bedding.config_dir(), newdir)

    def test_xdg_config_home(self):
        """When XDG_CONFIG_HOME is set, use it."""
        xdgconfigdir = osutils.pathjoin(self.test_home_dir, 'xdgconfig')
        self.overrideEnv('XDG_CONFIG_HOME', xdgconfigdir)
        newdir = osutils.pathjoin(xdgconfigdir, 'bazaar')
        os.makedirs(newdir)
        self.assertEqual(bedding.config_dir(), newdir)

    def test_ensure_config_dir_exists(self):
        xdgconfigdir = osutils.pathjoin(self.test_home_dir, 'xdgconfig')
        self.overrideEnv('XDG_CONFIG_HOME', xdgconfigdir)
        bedding.ensure_config_dir_exists()
        newdir = osutils.pathjoin(xdgconfigdir, 'breezy')
        self.assertTrue(os.path.isdir(newdir))


class TestDefaultMailDomain(tests.TestCaseInTempDir):
    """Test retrieving default domain from mailname file"""

    def test_default_mail_domain_simple(self):
        with open('simple', 'w') as f:
            f.write("domainname.com\n")
        r = bedding._get_default_mail_domain('simple')
        self.assertEqual('domainname.com', r)

    def test_default_mail_domain_no_eol(self):
        with open('no_eol', 'w') as f:
            f.write("domainname.com")
        r = bedding._get_default_mail_domain('no_eol')
        self.assertEqual('domainname.com', r)

    def test_default_mail_domain_multiple_lines(self):
        with open('multiple_lines', 'w') as f:
            f.write("domainname.com\nsome other text\n")
        r = bedding._get_default_mail_domain('multiple_lines')
        self.assertEqual('domainname.com', r)


class TestAutoUserId(tests.TestCase):
    """Test inferring an automatic user name."""

    def test_auto_user_id(self):
        """Automatic inference of user name.

        This is a bit hard to test in an isolated way, because it depends on
        system functions that go direct to /etc or perhaps somewhere else.
        But it's reasonable to say that on Unix, with an /etc/mailname, we ought
        to be able to choose a user name with no configuration.
        """
        if sys.platform == 'win32':
            raise tests.TestSkipped(
                "User name inference not implemented on win32")
        realname, address = bedding._auto_user_id()
        if os.path.exists('/etc/mailname'):
            self.assertIsNot(None, realname)
            self.assertIsNot(None, address)
        else:
            self.assertEqual((None, None), (realname, address))


class TestXDGCacheDir(tests.TestCaseInTempDir):
    # must be in temp dir because tests for the existence of the breezy
    # subdirectory of $XDG_CACHE_HOME

    def setUp(self):
        super(TestXDGCacheDir, self).setUp()
        if sys.platform in ('darwin', 'win32'):
            raise tests.TestNotApplicable(
                'XDG cache dir not used on this platform')
        self.overrideEnv('HOME', self.test_home_dir)
        # BZR_HOME overrides everything we want to test so unset it.
        self.overrideEnv('BZR_HOME', None)

    def test_xdg_cache_dir_exists(self):
        """When ~/.cache/breezy exists, use it as the cache dir."""
        cachedir = osutils.pathjoin(self.test_home_dir, '.cache')
        newdir = osutils.pathjoin(cachedir, 'breezy')
        self.assertEqual(bedding.cache_dir(), newdir)

    def test_xdg_cache_home_unix(self):
        """When XDG_CACHE_HOME is set, use it."""
        if sys.platform in ('nt', 'win32'):
            raise tests.TestNotApplicable(
                'XDG cache dir not used on this platform')
        xdgcachedir = osutils.pathjoin(self.test_home_dir, 'xdgcache')
        self.overrideEnv('XDG_CACHE_HOME', xdgcachedir)
        newdir = osutils.pathjoin(xdgcachedir, 'breezy')
        self.assertEqual(bedding.cache_dir(), newdir)
