/brz/remove-bazaar

# Copyright (C) 2005-2012, 2016 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 the breezy ui."""

import time

from testtools.matchers import *

from .. import (

    config,

    tests,

    ui as _mod_ui,

    )

from ..bzr import (

    remote,

    )

from . import (

    fixtures,

    ui_testing,

    )

from ..ui import text as _mod_ui_text

from .testui import (

    ProgressRecordingUIFactory,

    )

class TestUIConfiguration(tests.TestCaseInTempDir):

    def test_output_encoding_configuration(self):

        enc = next(fixtures.generate_unicode_encodings())

        config.GlobalStack().set('output_encoding', enc)

        IO = ui_testing.BytesIOWithEncoding

        ui = _mod_ui.make_ui_for_terminal(IO(), IO(), IO())

        output = ui.make_output_stream()

        self.assertEqual(output.encoding, enc)

class TestTextUIFactory(tests.TestCase):

    def test_text_factory_confirm(self):

        # turns into reading a regular boolean

        with ui_testing.TestUIFactory('n\n') as ui:

            self.assertEqual(

                False,

                ui.confirm_action(

                    u'Should %(thing)s pass?',

                    'breezy.tests.test_ui.confirmation',

                    {'thing': 'this'}))

    def test_text_factory_ascii_password(self):

        ui = ui_testing.TestUIFactory('secret\n')

        with ui.nested_progress_bar():

            self.assertEqual('secret',

                             self.apply_redirected(ui.stdin, ui.stdout,

                                                   ui.stderr,

                                                   ui.get_password))

            # ': ' is appended to prompt

            self.assertEqual(': ', ui.stderr.getvalue())

            self.assertEqual('', ui.stdout.readline())

            # stdin should be empty

            self.assertEqual('', ui.stdin.readline())

    def test_text_factory_unicode_password(self):

        """Test a unicode password."""

        ui = ui_testing.TextUIFactory(u'baz\u1234')

        password = ui.get_password(

            u'Hello \u1234 %(user)s', user=u'some\u1234')

        self.assertEqual(u'baz\u1234', password)

        self.assertEqual(u'Hello \u1234 some\u1234: ', ui.stderr.getvalue())

        # stdin and stdout should be empty

        self.assertEqual('', ui.stdin.readline())

        self.assertEqual('', ui.stdout.getvalue())

    def test_text_ui_get_boolean(self):

        stdin_text = (

            "y\n"  # True

            "n\n"  # False

            " \n y \n"  # True

            " no \n"  # False

            "yes with garbage\nY\n"  # True

            "not an answer\nno\n"  # False

            "I'm sure!\nyes\n"  # True

            "NO\n"  # False

            "foo\n")

        with ui_testing.TextUIFactory(stdin_text) as factory:

            self.assertEqual(True, factory.get_boolean(u""))

            self.assertEqual(False, factory.get_boolean(u""))

            self.assertEqual(True, factory.get_boolean(u""))

            self.assertEqual(False, factory.get_boolean(u""))

            self.assertEqual(True, factory.get_boolean(u""))

            self.assertEqual(False, factory.get_boolean(u""))

            self.assertEqual(True, factory.get_boolean(u""))

            self.assertEqual(False, factory.get_boolean(u""))

            self.assertEqual("foo\n", factory.stdin.read())

            # stdin should be empty

            self.assertEqual('', factory.stdin.readline())

            # return false on EOF

            self.assertEqual(False, factory.get_boolean(u""))

    def test_text_ui_choose_bad_parameters(self):

        with ui_testing.TextUIFactory(u"") as factory:

            # invalid default index

            self.assertRaises(ValueError, factory.choose, u"", u"&Yes\n&No", 3)

            # duplicated choice

            self.assertRaises(

                ValueError, factory.choose, u"", u"&choice\n&ChOiCe")

            # duplicated shortcut

            self.assertRaises(

                ValueError, factory.choose, u"", u"&choice1\nchoi&ce2")

    def test_text_ui_choose_prompt_explicit(self):

        # choices with explicit shortcuts

        with ui_testing.TextUIFactory(u"") as factory:

            factory.choose(u"prompt", u"&yes\n&No\nmore &info")

            self.assertEqual(

                "prompt ([y]es, [N]o, more [i]nfo): \n",

                factory.stderr.getvalue())

    def test_text_ui_choose_prompt_automatic(self):

        # automatic shortcuts

        with ui_testing.TextUIFactory(u"") as factory:

            factory.choose(u"prompt", u"yes\nNo\nmore info")

            self.assertEqual(

                "prompt ([y]es, [N]o, [m]ore info): \n",

                factory.stderr.getvalue())

    def test_text_ui_choose_return_values(self):

        def choose():

            return factory.choose(u"", u"&Yes\n&No\nMaybe\nmore &info", 3)

        stdin_text = (

            "y\n"  # 0

            "n\n"  # 1

            " \n"  # default: 3

            " no \n"  # 1

            "b\na\nd \n"  # bad shortcuts, all ignored

            "yes with garbage\nY\n"  # 0

            "not an answer\nno\n"  # 1

            "info\nmore info\n"  # 3

            "Maybe\n"  # 2

            "foo\n")

        with ui_testing.TextUIFactory(stdin_text) as factory:

            self.assertEqual(0, choose())

            self.assertEqual(1, choose())

            self.assertEqual(3, choose())

            self.assertEqual(1, choose())

            self.assertEqual(0, choose())

            self.assertEqual(1, choose())

            self.assertEqual(3, choose())

            self.assertEqual(2, choose())

            self.assertEqual("foo\n", factory.stdin.read())

            # stdin should be empty

            self.assertEqual('', factory.stdin.readline())

            # return None on EOF

            self.assertEqual(None, choose())

    def test_text_ui_choose_no_default(self):

        stdin_text = (

            " \n"  # no default, invalid!

            " yes \n"  # 0

            "foo\n")

        with ui_testing.TextUIFactory(stdin_text) as factory:

            self.assertEqual(0, factory.choose(u"", u"&Yes\n&No"))

            self.assertEqual("foo\n", factory.stdin.read())

    def test_text_ui_get_integer(self):

        stdin_text = (

            "1\n"

            "  -2  \n"

            "hmmm\nwhat else ?\nCome on\nok 42\n4.24\n42\n")

        with ui_testing.TextUIFactory(stdin_text) as factory:

            self.assertEqual(1, factory.get_integer(u""))

            self.assertEqual(-2, factory.get_integer(u""))

            self.assertEqual(42, factory.get_integer(u""))

    def test_text_factory_prompt(self):

        # see <https://launchpad.net/bugs/365891>

        with ui_testing.TextUIFactory() as factory:

            factory.prompt(u'foo %2e')

            self.assertEqual('', factory.stdout.getvalue())

            self.assertEqual('foo %2e', factory.stderr.getvalue())

    def test_text_factory_prompts_and_clears(self):

        # a get_boolean call should clear the pb before prompting

        out = ui_testing.StringIOAsTTY()

        self.overrideEnv('TERM', 'xterm')

        factory = ui_testing.TextUIFactory("yada\ny\n", stdout=out, stderr=out)

        with factory:

            pb = factory.nested_progress_bar()

            pb._avail_width = lambda: 79

            pb.show_bar = False

            pb.show_spinner = False

            pb.show_count = False

            pb.update("foo", 0, 1)

            self.assertEqual(

                True,

                self.apply_redirected(

                    None, factory.stdout, factory.stdout, factory.get_boolean,

                    u"what do you want"))

            output = out.getvalue()

            self.assertContainsRe(output,

                                  "| foo *\r\r  *\r*")

            self.assertContainsString(

                output,

                r"what do you want? ([y]es, [n]o): what do you want? "

                r"([y]es, [n]o): ")

            # stdin should have been totally consumed

            self.assertEqual('', factory.stdin.readline())

    def test_text_tick_after_update(self):

        ui_factory = ui_testing.TextUIFactory()

        with ui_factory.nested_progress_bar() as pb:

            pb.update('task', 0, 3)

            # Reset the clock, so that it actually tries to repaint itself

            ui_factory._progress_view._last_repaint = time.time() - 1.0

            pb.tick()

    def test_text_ui_getusername(self):

        ui = ui_testing.TextUIFactory('someuser\n\n')

        self.assertEqual('someuser',

                         ui.get_username(u'Hello %(host)s', host='some'))

        self.assertEqual('Hello some: ', ui.stderr.getvalue())

        self.assertEqual('', ui.stdout.getvalue())

        self.assertEqual('', ui.get_username(u"Gebruiker"))

        # stdin should be empty

        self.assertEqual('', ui.stdin.readline())

    def test_text_ui_getusername_unicode(self):

        ui = ui_testing.TextUIFactory(u'someuser\u1234')

        username = ui.get_username(u'Hello %(host)s', host=u'some\u1234')

        self.assertEqual(u"someuser\u1234", username)

        self.assertEqual(u"Hello some\u1234: ", ui.stderr.getvalue())

        self.assertEqual('', ui.stdout.getvalue())

    def test_quietness(self):

        self.overrideEnv('BRZ_PROGRESS_BAR', 'text')

        ui_factory = ui_testing.TextUIFactory(

            stderr=ui_testing.StringIOAsTTY())

        with ui_factory:

            self.assertIsInstance(ui_factory._progress_view,

                                  _mod_ui_text.TextProgressView)

            ui_factory.be_quiet(True)

            self.assertIsInstance(ui_factory._progress_view,

                                  _mod_ui_text.NullProgressView)

    def test_text_ui_show_user_warning(self):

        from ..bzr.groupcompress_repo import RepositoryFormat2a

        from ..bzr.knitpack_repo import RepositoryFormatKnitPack5

        ui = ui_testing.TextUIFactory()

        remote_fmt = remote.RemoteRepositoryFormat()

        remote_fmt._network_name = RepositoryFormatKnitPack5().network_name()

        ui.show_user_warning(

            'cross_format_fetch', from_format=RepositoryFormat2a(),

            to_format=remote_fmt)

        self.assertEqual('', ui.stdout.getvalue())

        self.assertContainsRe(

            ui.stderr.getvalue(),

            "^Doing on-the-fly conversion from RepositoryFormat2a\\(\\) to "

            "RemoteRepositoryFormat\\(_network_name="

            "b?'Bazaar RepositoryFormatKnitPack5 \\(bzr 1.6\\)\\\\n'\\)\\.\n"

            "This may take some time. Upgrade the repositories to "

            "the same format for better performance\\.\n$")

        # and now with it suppressed please

        ui = ui_testing.TextUIFactory()

        ui.suppressed_warnings.add('cross_format_fetch')

        ui.show_user_warning(

            'cross_format_fetch', from_format=RepositoryFormat2a(),

            to_format=remote_fmt)

        self.assertEqual('', ui.stdout.getvalue())

        self.assertEqual('', ui.stderr.getvalue())

class TestTextUIOutputStream(tests.TestCase):

    """Tests for output stream that synchronizes with progress bar."""

    def test_output_clears_terminal(self):

        clear_calls = []

        uif = ui_testing.TextUIFactory()

        uif.clear_term = lambda: clear_calls.append('clear')

        stream = _mod_ui_text.TextUIOutputStream(

            uif, uif.stdout, 'utf-8', 'strict')

        stream.write(u"Hello world!\n")

        stream.write(u"there's more...\n")

        stream.writelines([u"1\n", u"2\n", u"3\n"])

        self.assertEqual(uif.stdout.getvalue(),

                         u"Hello world!\n"

                         u"there's more...\n"

                         u"1\n2\n3\n")

        self.assertEqual(['clear', 'clear', 'clear'],

                         clear_calls)

        stream.flush()

class UITests(tests.TestCase):

    def test_progress_construction(self):

        """TextUIFactory constructs the right progress view.

        """

        FileStringIO = ui_testing.StringIOWithEncoding

        TTYStringIO = ui_testing.StringIOAsTTY

        for (file_class, term, pb, expected_pb_class) in (

                # on an xterm, either use them or not as the user requests,

                # otherwise default on

                (TTYStringIO, 'xterm', 'none', _mod_ui_text.NullProgressView),

                (TTYStringIO, 'xterm', 'text', _mod_ui_text.TextProgressView),

                (TTYStringIO, 'xterm', None, _mod_ui_text.TextProgressView),

                # on a dumb terminal, again if there's explicit configuration

                # do it, otherwise default off

                (TTYStringIO, 'dumb', 'none', _mod_ui_text.NullProgressView),

                (TTYStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),

                (TTYStringIO, 'dumb', None, _mod_ui_text.NullProgressView),

                # on a non-tty terminal, it's null regardless of $TERM

                (FileStringIO, 'xterm', None, _mod_ui_text.NullProgressView),

                (FileStringIO, 'dumb', None, _mod_ui_text.NullProgressView),

                # however, it can still be forced on

                (FileStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),

                ):

            self.overrideEnv('TERM', term)

            self.overrideEnv('BRZ_PROGRESS_BAR', pb)

            stdin = file_class(u'')

            stderr = file_class()

            stdout = file_class()

            uif = _mod_ui.make_ui_for_terminal(stdin, stdout, stderr)

            self.assertIsInstance(

                uif, _mod_ui_text.TextUIFactory,

                "TERM=%s BRZ_PROGRESS_BAR=%s uif=%r" % (term, pb, uif,))

            self.assertIsInstance(

                uif.make_progress_view(),

                expected_pb_class,

                "TERM=%s BRZ_PROGRESS_BAR=%s uif=%r" % (term, pb, uif,))

    def test_text_ui_non_terminal(self):

        """Even on non-ttys, make_ui_for_terminal gives a text ui."""

        stdin = stderr = stdout = ui_testing.StringIOWithEncoding()

        for term_type in ['dumb', None, 'xterm']:

            self.overrideEnv('TERM', term_type)

            uif = _mod_ui.make_ui_for_terminal(stdin, stdout, stderr)

            self.assertIsInstance(uif, _mod_ui_text.TextUIFactory,

                                  'TERM=%r' % (term_type,))

class SilentUITests(tests.TestCase):

    def test_silent_factory_get_password(self):

        # A silent factory that can't do user interaction can't get a

        # password.  Possibly it should raise a more specific error but it

        # can't succeed.

        ui = _mod_ui.SilentUIFactory()

        stdout = ui_testing.StringIOWithEncoding()

        self.assertRaises(

            NotImplementedError,

            self.apply_redirected,

            None, stdout, stdout, ui.get_password)

        # and it didn't write anything out either

        self.assertEqual('', stdout.getvalue())

    def test_silent_ui_getbool(self):

        factory = _mod_ui.SilentUIFactory()

        stdout = ui_testing.StringIOWithEncoding()

        self.assertRaises(

            NotImplementedError,

            self.apply_redirected,

            None, stdout, stdout, factory.get_boolean, u"foo")

class TestUIFactoryTests(tests.TestCase):

    def test_test_ui_factory_progress(self):

        # there's no output; we just want to make sure this doesn't crash -

        # see https://bugs.launchpad.net/bzr/+bug/408201

        ui = ui_testing.TestUIFactory()

        with ui.nested_progress_bar() as pb:

            pb.update('hello')

            pb.tick()

class CannedInputUIFactoryTests(tests.TestCase):

    def test_canned_input_get_input(self):

        uif = _mod_ui.CannedInputUIFactory([True, 'mbp', 'password', 42])

        self.assertEqual(True, uif.get_boolean(u'Extra cheese?'))

        self.assertEqual('mbp', uif.get_username(u'Enter your user name'))

        self.assertEqual('password',

                         uif.get_password(u'Password for %(host)s',

                                          host='example.com'))

        self.assertEqual(42, uif.get_integer(u'And all that jazz ?'))

class TestBoolFromString(tests.TestCase):

    def assertIsTrue(self, s, accepted_values=None):

        res = _mod_ui.bool_from_string(s, accepted_values=accepted_values)

        self.assertEqual(True, res)

    def assertIsFalse(self, s, accepted_values=None):

        res = _mod_ui.bool_from_string(s, accepted_values=accepted_values)

        self.assertEqual(False, res)

    def assertIsNone(self, s, accepted_values=None):

        res = _mod_ui.bool_from_string(s, accepted_values=accepted_values)

        self.assertIs(None, res)

    def test_know_valid_values(self):

        self.assertIsTrue('true')

        self.assertIsFalse('false')

        self.assertIsTrue('1')

        self.assertIsFalse('0')

        self.assertIsTrue('on')

        self.assertIsFalse('off')

        self.assertIsTrue('yes')

        self.assertIsFalse('no')

        self.assertIsTrue('y')

        self.assertIsFalse('n')

        # Also try some case variations

        self.assertIsTrue('True')

        self.assertIsFalse('False')

        self.assertIsTrue('On')

        self.assertIsFalse('Off')

        self.assertIsTrue('ON')

        self.assertIsFalse('OFF')

        self.assertIsTrue('oN')

        self.assertIsFalse('oFf')

    def test_invalid_values(self):

        self.assertIsNone(None)

        self.assertIsNone('doubt')

        self.assertIsNone('frue')

        self.assertIsNone('talse')

        self.assertIsNone('42')

    def test_provided_values(self):

        av = dict(y=True, n=False, yes=True, no=False)

        self.assertIsTrue('y', av)

        self.assertIsTrue('Y', av)

        self.assertIsTrue('Yes', av)

        self.assertIsFalse('n', av)

        self.assertIsFalse('N', av)

        self.assertIsFalse('No', av)

        self.assertIsNone('1', av)

        self.assertIsNone('0', av)

        self.assertIsNone('on', av)

        self.assertIsNone('off', av)

class TestConfirmationUserInterfacePolicy(tests.TestCase):

    def test_confirm_action_default(self):

        base_ui = _mod_ui.NoninteractiveUIFactory()

        for answer in [True, False]:

            self.assertEqual(

                _mod_ui.ConfirmationUserInterfacePolicy(base_ui, answer, {})

                .confirm_action("Do something?",

                                "breezy.tests.do_something", {}),

                answer)

    def test_confirm_action_specific(self):

        base_ui = _mod_ui.NoninteractiveUIFactory()

        for default_answer in [True, False]:

            for specific_answer in [True, False]:

                for conf_id in ['given_id', 'other_id']:

                    wrapper = _mod_ui.ConfirmationUserInterfacePolicy(

                        base_ui, default_answer,

                        dict(given_id=specific_answer))

                    result = wrapper.confirm_action(

                        "Do something?", conf_id, {})

                    if conf_id == 'given_id':

                        self.assertEqual(result, specific_answer)

                    else:

                        self.assertEqual(result, default_answer)

    def test_repr(self):

        base_ui = _mod_ui.NoninteractiveUIFactory()

        wrapper = _mod_ui.ConfirmationUserInterfacePolicy(

            base_ui, True, dict(a=2))

        self.assertThat(repr(wrapper),

                        Equals("ConfirmationUserInterfacePolicy("

                               "NoninteractiveUIFactory(), True, {'a': 2})"))

class TestProgressRecordingUI(tests.TestCase):

    """Test test-oriented UIFactory that records progress updates"""

    def test_nested_ignore_depth_beyond_one(self):

        # we only want to capture the first level out progress, not

        # want sub-components might do. So we have nested bars ignored.

        factory = ProgressRecordingUIFactory()

        pb1 = factory.nested_progress_bar()

        pb1.update('foo', 0, 1)

        pb2 = factory.nested_progress_bar()

        pb2.update('foo', 0, 1)

        pb2.finished()

        pb1.finished()

        self.assertEqual([("update", 0, 1, 'foo')], factory._calls)