# 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 the bzrlib ui """ import os import time from StringIO import StringIO from testtools.matchers import * from bzrlib import ( config, errors, remote, repository, tests, ui as _mod_ui, ) from bzrlib.symbol_versioning import ( deprecated_in, ) from bzrlib.tests import ( fixtures, test_progress, ) from bzrlib.ui import text as _mod_ui_text from bzrlib.tests.testui import ( ProgressRecordingUIFactory, ) class TestUIConfiguration(tests.TestCaseWithTransport): def test_output_encoding_configuration(self): enc = fixtures.generate_unicode_encodings().next() config.GlobalConfig().set_user_option('output_encoding', enc) ui = tests.TestUIFactory(stdin=None, stdout=tests.StringIOWrapper(), stderr=tests.StringIOWrapper()) output = ui.make_output_stream() self.assertEquals(output.encoding, enc) class TestTextUIFactory(tests.TestCase): def make_test_ui_factory(self, stdin_contents): ui = tests.TestUIFactory(stdin=stdin_contents, stdout=tests.StringIOWrapper(), stderr=tests.StringIOWrapper()) return ui def test_text_factory_confirm(self): # turns into reading a regular boolean ui = self.make_test_ui_factory('n\n') self.assertEquals(ui.confirm_action('Should %(thing)s pass?', 'bzrlib.tests.test_ui.confirmation', {'thing': 'this'},), False) def test_text_factory_ascii_password(self): ui = self.make_test_ui_factory('secret\n') pb = ui.nested_progress_bar() try: 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()) finally: pb.finished() def test_text_factory_utf8_password(self): """Test an utf8 password. We can't predict what encoding users will have for stdin, so we force it to utf8 to test that we transport the password correctly. """ ui = self.make_test_ui_factory(u'baz\u1234'.encode('utf8')) ui.stderr.encoding = ui.stdout.encoding = ui.stdin.encoding = 'utf8' pb = ui.nested_progress_bar() try: password = self.apply_redirected(ui.stdin, ui.stdout, ui.stderr, ui.get_password, u'Hello \u1234 %(user)s', user=u'some\u1234') # We use StringIO objects, we need to decode them self.assertEqual(u'baz\u1234', password.decode('utf8')) self.assertEqual(u'Hello \u1234 some\u1234: ', ui.stderr.getvalue().decode('utf8')) # stdin and stdout should be empty self.assertEqual('', ui.stdin.readline()) self.assertEqual('', ui.stdout.readline()) finally: pb.finished() def test_text_ui_get_boolean(self): stdin = tests.StringIOWrapper("y\n" # True "n\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") stdout = tests.StringIOWrapper() stderr = tests.StringIOWrapper() factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr) self.assertEqual(True, factory.get_boolean("")) self.assertEqual(False, factory.get_boolean("")) self.assertEqual(True, factory.get_boolean("")) self.assertEqual(False, factory.get_boolean("")) self.assertEqual(True, factory.get_boolean("")) self.assertEqual(False, factory.get_boolean("")) self.assertEqual("foo\n", factory.stdin.read()) # stdin should be empty self.assertEqual('', factory.stdin.readline()) def test_text_ui_get_integer(self): stdin = tests.StringIOWrapper( "1\n" " -2 \n" "hmmm\nwhat else ?\nCome on\nok 42\n4.24\n42\n") stdout = tests.StringIOWrapper() stderr = tests.StringIOWrapper() factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr) self.assertEqual(1, factory.get_integer("")) self.assertEqual(-2, factory.get_integer("")) self.assertEqual(42, factory.get_integer("")) def test_text_factory_prompt(self): # see StringIO = tests.StringIOWrapper factory = _mod_ui_text.TextUIFactory(StringIO(), StringIO(), StringIO()) factory.prompt('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 = test_progress._TTYStringIO() os.environ['TERM'] = 'xterm' factory = _mod_ui_text.TextUIFactory( stdin=tests.StringIOWrapper("yada\ny\n"), stdout=out, stderr=out) factory._avail_width = lambda: 79 pb = factory.nested_progress_bar() 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, "what do you want")) output = out.getvalue() self.assertContainsRe(output, "| foo *\r\r *\r*") self.assertContainsRe(output, r"what do you want\? \[y/n\]: what do you want\? \[y/n\]: ") # stdin should have been totally consumed self.assertEqual('', factory.stdin.readline()) def test_text_tick_after_update(self): ui_factory = _mod_ui_text.TextUIFactory(stdout=tests.StringIOWrapper(), stderr=tests.StringIOWrapper()) pb = ui_factory.nested_progress_bar() try: 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() finally: pb.finished() def test_text_ui_getusername(self): factory = _mod_ui_text.TextUIFactory(None, None, None) factory.stdin = tests.StringIOWrapper("someuser\n\n") factory.stdout = tests.StringIOWrapper() factory.stderr = tests.StringIOWrapper() factory.stdout.encoding = "utf8" # there is no output from the base factory self.assertEqual("someuser", factory.get_username('Hello %(host)s', host='some')) self.assertEquals("Hello some: ", factory.stderr.getvalue()) self.assertEquals('', factory.stdout.getvalue()) self.assertEqual("", factory.get_username("Gebruiker")) # stdin should be empty self.assertEqual('', factory.stdin.readline()) def test_text_ui_getusername_utf8(self): ui = tests.TestUIFactory(stdin=u'someuser\u1234'.encode('utf8'), stdout=tests.StringIOWrapper(), stderr=tests.StringIOWrapper()) ui.stderr.encoding = ui.stdout.encoding = ui.stdin.encoding = "utf8" pb = ui.nested_progress_bar() try: # there is no output from the base factory username = self.apply_redirected(ui.stdin, ui.stdout, ui.stderr, ui.get_username, u'Hello\u1234 %(host)s', host=u'some\u1234') self.assertEquals(u"someuser\u1234", username.decode('utf8')) self.assertEquals(u"Hello\u1234 some\u1234: ", ui.stderr.getvalue().decode("utf8")) self.assertEquals('', ui.stdout.getvalue()) finally: pb.finished() def test_quietness(self): os.environ['BZR_PROGRESS_BAR'] = 'text' ui_factory = _mod_ui_text.TextUIFactory(None, test_progress._TTYStringIO(), test_progress._TTYStringIO()) 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 bzrlib.repofmt.groupcompress_repo import RepositoryFormat2a from bzrlib.repofmt.pack_repo import RepositoryFormatKnitPack5 err = StringIO() out = StringIO() ui = tests.TextUIFactory(stdin=None, stdout=out, stderr=err) 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.assertEquals('', out.getvalue()) self.assertEquals("Doing on-the-fly conversion from RepositoryFormat2a() to " "RemoteRepositoryFormat(_network_name='Bazaar RepositoryFormatKnitPack5 " "(bzr 1.6)\\n').\nThis may take some time. Upgrade the repositories to " "the same format for better performance.\n", err.getvalue()) # and now with it suppressed please err = StringIO() out = StringIO() ui = tests.TextUIFactory(stdin=None, stdout=out, stderr=err) ui.suppressed_warnings.add('cross_format_fetch') ui.show_user_warning('cross_format_fetch', from_format=RepositoryFormat2a(), to_format=remote_fmt) self.assertEquals('', out.getvalue()) self.assertEquals('', err.getvalue()) class TestTextUIOutputStream(tests.TestCase): """Tests for output stream that synchronizes with progress bar.""" def test_output_clears_terminal(self): stdout = tests.StringIOWrapper() stderr = tests.StringIOWrapper() clear_calls = [] uif = _mod_ui_text.TextUIFactory(None, stdout, stderr) uif.clear_term = lambda: clear_calls.append('clear') stream = _mod_ui_text.TextUIOutputStream(uif, uif.stdout) stream.write("Hello world!\n") stream.write("there's more...\n") stream.writelines(["1\n", "2\n", "3\n"]) self.assertEqual(stdout.getvalue(), "Hello world!\n" "there's more...\n" "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. """ TTYStringIO = test_progress._TTYStringIO FileStringIO = tests.StringIOWrapper 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), ): os.environ['TERM'] = term if pb is None: if 'BZR_PROGRESS_BAR' in os.environ: del os.environ['BZR_PROGRESS_BAR'] else: os.environ['BZR_PROGRESS_BAR'] = pb stdin = file_class('') 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 BZR_PROGRESS_BAR=%s uif=%r" % (term, pb, uif,)) self.assertIsInstance(uif.make_progress_view(), expected_pb_class, "TERM=%s BZR_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 = test_progress._NonTTYStringIO('') stderr = test_progress._NonTTYStringIO() stdout = test_progress._NonTTYStringIO() for term_type in ['dumb', None, 'xterm']: if term_type is None: del os.environ['TERM'] else: os.environ['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 = tests.StringIOWrapper() 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 = tests.StringIOWrapper() self.assertRaises( NotImplementedError, self.apply_redirected, None, stdout, stdout, factory.get_boolean, "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 = tests.TestUIFactory() pb = ui.nested_progress_bar() pb.update('hello') pb.tick() pb.finished() 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('Extra cheese?')) self.assertEqual('mbp', uif.get_username('Enter your user name')) self.assertEqual('password', uif.get_password('Password for %(host)s', host='example.com')) self.assertEqual(42, uif.get_integer('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.assertEquals(True, res) def assertIsFalse(self, s, accepted_values=None): res = _mod_ui.bool_from_string(s, accepted_values=accepted_values) self.assertEquals(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.assertEquals( _mod_ui.ConfirmationUserInterfacePolicy(base_ui, answer, {}) .confirm_action("Do something?", "bzrlib.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.assertEquals(result, specific_answer) else: self.assertEquals(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)