← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_ui.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-02-01 13:53:24 UTC
  • mfrom: (4990.1.2 rm-obsolete)
  • Revision ID: pqm@pqm.ubuntu.com-20100201135324-cuhuolr97guf5xjp
(Jelmer) Remove obsolete (and broken) biobench and history2revfiles
        tools.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_ui.py
 
1
# Copyright (C) 2005, 2008, 2009, 2010 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""Tests for the bzrlib ui
 
18
"""
 
19
 
 
20
import os
 
21
import re
 
22
import time
 
23
 
 
24
from bzrlib import (
 
25
    errors,
 
26
    tests,
 
27
    ui as _mod_ui,
 
28
    )
 
29
from bzrlib.symbol_versioning import (
 
30
    deprecated_in,
 
31
    )
 
32
from bzrlib.tests import test_progress
 
33
from bzrlib.ui import text as _mod_ui_text
 
34
 
 
35
 
 
36
class TestTextUIFactory(tests.TestCase):
 
37
 
 
38
    def test_text_factory_ascii_password(self):
 
39
        ui = tests.TestUIFactory(stdin='secret\n',
 
40
                                 stdout=tests.StringIOWrapper(),
 
41
                                 stderr=tests.StringIOWrapper())
 
42
        pb = ui.nested_progress_bar()
 
43
        try:
 
44
            self.assertEqual('secret',
 
45
                             self.apply_redirected(ui.stdin, ui.stdout,
 
46
                                                   ui.stderr,
 
47
                                                   ui.get_password))
 
48
            # ': ' is appended to prompt
 
49
            self.assertEqual(': ', ui.stderr.getvalue())
 
50
            self.assertEqual('', ui.stdout.readline())
 
51
            # stdin should be empty
 
52
            self.assertEqual('', ui.stdin.readline())
 
53
        finally:
 
54
            pb.finished()
 
55
 
 
56
    def test_text_factory_utf8_password(self):
 
57
        """Test an utf8 password.
 
58
 
 
59
        We can't predict what encoding users will have for stdin, so we force
 
60
        it to utf8 to test that we transport the password correctly.
 
61
        """
 
62
        ui = tests.TestUIFactory(stdin=u'baz\u1234'.encode('utf8'),
 
63
                                 stdout=tests.StringIOWrapper(),
 
64
                                 stderr=tests.StringIOWrapper())
 
65
        ui.stderr.encoding = ui.stdout.encoding = ui.stdin.encoding = 'utf8'
 
66
        pb = ui.nested_progress_bar()
 
67
        try:
 
68
            password = self.apply_redirected(ui.stdin, ui.stdout, ui.stderr,
 
69
                                             ui.get_password,
 
70
                                             u'Hello \u1234 %(user)s',
 
71
                                             user=u'some\u1234')
 
72
            # We use StringIO objects, we need to decode them
 
73
            self.assertEqual(u'baz\u1234', password.decode('utf8'))
 
74
            self.assertEqual(u'Hello \u1234 some\u1234: ',
 
75
                             ui.stderr.getvalue().decode('utf8'))
 
76
            # stdin and stdout should be empty
 
77
            self.assertEqual('', ui.stdin.readline())
 
78
            self.assertEqual('', ui.stdout.readline())
 
79
        finally:
 
80
            pb.finished()
 
81
 
 
82
    def test_progress_note(self):
 
83
        stderr = tests.StringIOWrapper()
 
84
        stdout = tests.StringIOWrapper()
 
85
        ui_factory = _mod_ui_text.TextUIFactory(stdin=tests.StringIOWrapper(''),
 
86
                                                stderr=stderr,
 
87
                                                stdout=stdout)
 
88
        pb = ui_factory.nested_progress_bar()
 
89
        try:
 
90
            result = self.applyDeprecated(deprecated_in((2, 1, 0)),
 
91
                pb.note,
 
92
                't')
 
93
            self.assertEqual(None, result)
 
94
            self.assertEqual("t\n", stdout.getvalue())
 
95
            # Since there was no update() call, there should be no clear() call
 
96
            self.failIf(re.search(r'^\r {10,}\r$',
 
97
                                  stderr.getvalue()) is not None,
 
98
                        'We cleared the stderr without anything to put there')
 
99
        finally:
 
100
            pb.finished()
 
101
 
 
102
    def test_progress_note_clears(self):
 
103
        stderr = test_progress._TTYStringIO()
 
104
        stdout = test_progress._TTYStringIO()
 
105
        # so that we get a TextProgressBar
 
106
        os.environ['TERM'] = 'xterm'
 
107
        ui_factory = _mod_ui_text.TextUIFactory(
 
108
            stdin=tests.StringIOWrapper(''),
 
109
            stdout=stdout, stderr=stderr)
 
110
        self.assertIsInstance(ui_factory._progress_view,
 
111
                              _mod_ui_text.TextProgressView)
 
112
        pb = ui_factory.nested_progress_bar()
 
113
        try:
 
114
            # Create a progress update that isn't throttled
 
115
            pb.update('x', 1, 1)
 
116
            result = self.applyDeprecated(deprecated_in((2, 1, 0)),
 
117
                pb.note, 't')
 
118
            self.assertEqual(None, result)
 
119
            self.assertEqual("t\n", stdout.getvalue())
 
120
            # the exact contents will depend on the terminal width and we don't
 
121
            # care about that right now - but you're probably running it on at
 
122
            # least a 10-character wide terminal :)
 
123
            self.assertContainsRe(stderr.getvalue(), r'\r {10,}\r$')
 
124
        finally:
 
125
            pb.finished()
 
126
 
 
127
    def test_progress_nested(self):
 
128
        # test factory based nested and popping.
 
129
        ui = _mod_ui_text.TextUIFactory(None, None, None)
 
130
        pb1 = ui.nested_progress_bar()
 
131
        pb2 = ui.nested_progress_bar()
 
132
        # You do get a warning if the outermost progress bar wasn't finished
 
133
        # first - it's not clear if this is really useful or if it should just
 
134
        # become orphaned -- mbp 20090120
 
135
        warnings, _ = self.callCatchWarnings(pb1.finished)
 
136
        if len(warnings) != 1:
 
137
            self.fail("unexpected warnings: %r" % (warnings,))
 
138
        pb2.finished()
 
139
        pb1.finished()
 
140
 
 
141
    def test_text_ui_get_boolean(self):
 
142
        stdin = tests.StringIOWrapper("y\n" # True
 
143
                                      "n\n" # False
 
144
                                      "yes with garbage\nY\n" # True
 
145
                                      "not an answer\nno\n" # False
 
146
                                      "I'm sure!\nyes\n" # True
 
147
                                      "NO\n" # False
 
148
                                      "foo\n")
 
149
        stdout = tests.StringIOWrapper()
 
150
        stderr = tests.StringIOWrapper()
 
151
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
 
152
        self.assertEqual(True, factory.get_boolean(""))
 
153
        self.assertEqual(False, factory.get_boolean(""))
 
154
        self.assertEqual(True, factory.get_boolean(""))
 
155
        self.assertEqual(False, factory.get_boolean(""))
 
156
        self.assertEqual(True, factory.get_boolean(""))
 
157
        self.assertEqual(False, factory.get_boolean(""))
 
158
        self.assertEqual("foo\n", factory.stdin.read())
 
159
        # stdin should be empty
 
160
        self.assertEqual('', factory.stdin.readline())
 
161
 
 
162
    def test_text_ui_get_integer(self):
 
163
        stdin = tests.StringIOWrapper(
 
164
            "1\n"
 
165
            "  -2  \n"
 
166
            "hmmm\nwhat else ?\nCome on\nok 42\n4.24\n42\n")
 
167
        stdout = tests.StringIOWrapper()
 
168
        stderr = tests.StringIOWrapper()
 
169
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
 
170
        self.assertEqual(1, factory.get_integer(""))
 
171
        self.assertEqual(-2, factory.get_integer(""))
 
172
        self.assertEqual(42, factory.get_integer(""))
 
173
 
 
174
    def test_text_factory_prompt(self):
 
175
        # see <https://launchpad.net/bugs/365891>
 
176
        StringIO = tests.StringIOWrapper
 
177
        factory = _mod_ui_text.TextUIFactory(StringIO(), StringIO(), StringIO())
 
178
        factory.prompt('foo %2e')
 
179
        self.assertEqual('', factory.stdout.getvalue())
 
180
        self.assertEqual('foo %2e', factory.stderr.getvalue())
 
181
 
 
182
    def test_text_factory_prompts_and_clears(self):
 
183
        # a get_boolean call should clear the pb before prompting
 
184
        out = test_progress._TTYStringIO()
 
185
        os.environ['TERM'] = 'xterm'
 
186
        factory = _mod_ui_text.TextUIFactory(
 
187
            stdin=tests.StringIOWrapper("yada\ny\n"),
 
188
            stdout=out, stderr=out)
 
189
        pb = factory.nested_progress_bar()
 
190
        pb.show_bar = False
 
191
        pb.show_spinner = False
 
192
        pb.show_count = False
 
193
        pb.update("foo", 0, 1)
 
194
        self.assertEqual(True,
 
195
                         self.apply_redirected(None, factory.stdout,
 
196
                                               factory.stdout,
 
197
                                               factory.get_boolean,
 
198
                                               "what do you want"))
 
199
        output = out.getvalue()
 
200
        self.assertContainsRe(factory.stdout.getvalue(),
 
201
            "foo *\r\r  *\r*")
 
202
        self.assertContainsRe(factory.stdout.getvalue(),
 
203
            r"what do you want\? \[y/n\]: what do you want\? \[y/n\]: ")
 
204
        # stdin should have been totally consumed
 
205
        self.assertEqual('', factory.stdin.readline())
 
206
 
 
207
    def test_text_tick_after_update(self):
 
208
        ui_factory = _mod_ui_text.TextUIFactory(stdout=tests.StringIOWrapper(),
 
209
                                                stderr=tests.StringIOWrapper())
 
210
        pb = ui_factory.nested_progress_bar()
 
211
        try:
 
212
            pb.update('task', 0, 3)
 
213
            # Reset the clock, so that it actually tries to repaint itself
 
214
            ui_factory._progress_view._last_repaint = time.time() - 1.0
 
215
            pb.tick()
 
216
        finally:
 
217
            pb.finished()
 
218
 
 
219
    def test_text_ui_getusername(self):
 
220
        factory = _mod_ui_text.TextUIFactory(None, None, None)
 
221
        factory.stdin = tests.StringIOWrapper("someuser\n\n")
 
222
        factory.stdout = tests.StringIOWrapper()
 
223
        factory.stderr = tests.StringIOWrapper()
 
224
        factory.stdout.encoding = "utf8"
 
225
        # there is no output from the base factory
 
226
        self.assertEqual("someuser",
 
227
                         factory.get_username('Hello %(host)s', host='some'))
 
228
        self.assertEquals("Hello some: ", factory.stderr.getvalue())
 
229
        self.assertEquals('', factory.stdout.getvalue())
 
230
        self.assertEqual("", factory.get_username("Gebruiker"))
 
231
        # stdin should be empty
 
232
        self.assertEqual('', factory.stdin.readline())
 
233
 
 
234
    def test_text_ui_getusername_utf8(self):
 
235
        ui = tests.TestUIFactory(stdin=u'someuser\u1234'.encode('utf8'),
 
236
                                 stdout=tests.StringIOWrapper(),
 
237
                                 stderr=tests.StringIOWrapper())
 
238
        ui.stderr.encoding = ui.stdout.encoding = ui.stdin.encoding = "utf8"
 
239
        pb = ui.nested_progress_bar()
 
240
        try:
 
241
            # there is no output from the base factory
 
242
            username = self.apply_redirected(ui.stdin, ui.stdout, ui.stderr,
 
243
                ui.get_username, u'Hello\u1234 %(host)s', host=u'some\u1234')
 
244
            self.assertEquals(u"someuser\u1234", username.decode('utf8'))
 
245
            self.assertEquals(u"Hello\u1234 some\u1234: ",
 
246
                              ui.stderr.getvalue().decode("utf8"))
 
247
            self.assertEquals('', ui.stdout.getvalue())
 
248
        finally:
 
249
            pb.finished()
 
250
 
 
251
    def test_quietness(self):
 
252
        os.environ['BZR_PROGRESS_BAR'] = 'text'
 
253
        ui_factory = _mod_ui_text.TextUIFactory(None,
 
254
            test_progress._TTYStringIO(),
 
255
            test_progress._TTYStringIO())
 
256
        self.assertIsInstance(ui_factory._progress_view,
 
257
            _mod_ui_text.TextProgressView)
 
258
        ui_factory.be_quiet(True)
 
259
        self.assertIsInstance(ui_factory._progress_view,
 
260
            _mod_ui_text.NullProgressView)
 
261
 
 
262
 
 
263
class TestTextUIOutputStream(tests.TestCase):
 
264
    """Tests for output stream that synchronizes with progress bar."""
 
265
 
 
266
    def test_output_clears_terminal(self):
 
267
        stdout = tests.StringIOWrapper()
 
268
        stderr = tests.StringIOWrapper()
 
269
        clear_calls = []
 
270
 
 
271
        uif =  _mod_ui_text.TextUIFactory(None, stdout, stderr)
 
272
        uif.clear_term = lambda: clear_calls.append('clear')
 
273
 
 
274
        stream = _mod_ui_text.TextUIOutputStream(uif, uif.stdout)
 
275
        stream.write("Hello world!\n")
 
276
        stream.write("there's more...\n")
 
277
        stream.writelines(["1\n", "2\n", "3\n"])
 
278
 
 
279
        self.assertEqual(stdout.getvalue(),
 
280
            "Hello world!\n"
 
281
            "there's more...\n"
 
282
            "1\n2\n3\n")
 
283
        self.assertEqual(['clear', 'clear', 'clear'],
 
284
            clear_calls)
 
285
 
 
286
        stream.flush()
 
287
 
 
288
 
 
289
class UITests(tests.TestCase):
 
290
 
 
291
    def test_progress_construction(self):
 
292
        """TextUIFactory constructs the right progress view.
 
293
        """
 
294
        TTYStringIO = test_progress._TTYStringIO
 
295
        FileStringIO = tests.StringIOWrapper
 
296
        for (file_class, term, pb, expected_pb_class) in (
 
297
            # on an xterm, either use them or not as the user requests,
 
298
            # otherwise default on
 
299
            (TTYStringIO, 'xterm', 'none', _mod_ui_text.NullProgressView),
 
300
            (TTYStringIO, 'xterm', 'text', _mod_ui_text.TextProgressView),
 
301
            (TTYStringIO, 'xterm', None, _mod_ui_text.TextProgressView),
 
302
            # on a dumb terminal, again if there's explicit configuration do
 
303
            # it, otherwise default off
 
304
            (TTYStringIO, 'dumb', 'none', _mod_ui_text.NullProgressView),
 
305
            (TTYStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),
 
306
            (TTYStringIO, 'dumb', None, _mod_ui_text.NullProgressView),
 
307
            # on a non-tty terminal, it's null regardless of $TERM
 
308
            (FileStringIO, 'xterm', None, _mod_ui_text.NullProgressView),
 
309
            (FileStringIO, 'dumb', None, _mod_ui_text.NullProgressView),
 
310
            # however, it can still be forced on
 
311
            (FileStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),
 
312
            ):
 
313
            os.environ['TERM'] = term
 
314
            if pb is None:
 
315
                if 'BZR_PROGRESS_BAR' in os.environ:
 
316
                    del os.environ['BZR_PROGRESS_BAR']
 
317
            else:
 
318
                os.environ['BZR_PROGRESS_BAR'] = pb
 
319
            stdin = file_class('')
 
320
            stderr = file_class()
 
321
            stdout = file_class()
 
322
            uif = _mod_ui.make_ui_for_terminal(stdin, stdout, stderr)
 
323
            self.assertIsInstance(uif, _mod_ui_text.TextUIFactory,
 
324
                "TERM=%s BZR_PROGRESS_BAR=%s uif=%r" % (term, pb, uif,))
 
325
            self.assertIsInstance(uif.make_progress_view(),
 
326
                expected_pb_class,
 
327
                "TERM=%s BZR_PROGRESS_BAR=%s uif=%r" % (term, pb, uif,))
 
328
 
 
329
    def test_text_ui_non_terminal(self):
 
330
        """Even on non-ttys, make_ui_for_terminal gives a text ui."""
 
331
        stdin = test_progress._NonTTYStringIO('')
 
332
        stderr = test_progress._NonTTYStringIO()
 
333
        stdout = test_progress._NonTTYStringIO()
 
334
        for term_type in ['dumb', None, 'xterm']:
 
335
            if term_type is None:
 
336
                del os.environ['TERM']
 
337
            else:
 
338
                os.environ['TERM'] = term_type
 
339
            uif = _mod_ui.make_ui_for_terminal(stdin, stdout, stderr)
 
340
            self.assertIsInstance(uif, _mod_ui_text.TextUIFactory,
 
341
                'TERM=%r' % (term_type,))
 
342
 
 
343
 
 
344
class SilentUITests(tests.TestCase):
 
345
 
 
346
    def test_silent_factory_get_password(self):
 
347
        # A silent factory that can't do user interaction can't get a
 
348
        # password.  Possibly it should raise a more specific error but it
 
349
        # can't succeed.
 
350
        ui = _mod_ui.SilentUIFactory()
 
351
        stdout = tests.StringIOWrapper()
 
352
        self.assertRaises(
 
353
            NotImplementedError,
 
354
            self.apply_redirected,
 
355
            None, stdout, stdout, ui.get_password)
 
356
        # and it didn't write anything out either
 
357
        self.assertEqual('', stdout.getvalue())
 
358
 
 
359
    def test_silent_ui_getbool(self):
 
360
        factory = _mod_ui.SilentUIFactory()
 
361
        stdout = tests.StringIOWrapper()
 
362
        self.assertRaises(
 
363
            NotImplementedError,
 
364
            self.apply_redirected,
 
365
            None, stdout, stdout, factory.get_boolean, "foo")
 
366
 
 
367
 
 
368
class TestUIFactoryTests(tests.TestCase):
 
369
 
 
370
    def test_test_ui_factory_progress(self):
 
371
        # there's no output; we just want to make sure this doesn't crash -
 
372
        # see https://bugs.edge.launchpad.net/bzr/+bug/408201
 
373
        ui = tests.TestUIFactory()
 
374
        pb = ui.nested_progress_bar()
 
375
        pb.update('hello')
 
376
        pb.tick()
 
377
        pb.finished()
 
378
 
 
379
 
 
380
class CannedInputUIFactoryTests(tests.TestCase):
 
381
 
 
382
    def test_canned_input_get_input(self):
 
383
        uif = _mod_ui.CannedInputUIFactory([True, 'mbp', 'password', 42])
 
384
        self.assertEqual(True, uif.get_boolean('Extra cheese?'))
 
385
        self.assertEqual('mbp', uif.get_username('Enter your user name'))
 
386
        self.assertEqual('password',
 
387
                         uif.get_password('Password for %(host)s',
 
388
                                          host='example.com'))
 
389
        self.assertEqual(42, uif.get_integer('And all that jazz ?'))
 
390
 
 
391
 
 
392
class TestBoolFromString(tests.TestCase):
 
393
 
 
394
    def assertIsTrue(self, s, accepted_values=None):
 
395
        res = _mod_ui.bool_from_string(s, accepted_values=accepted_values)
 
396
        self.assertEquals(True, res)
 
397
 
 
398
    def assertIsFalse(self, s, accepted_values=None):
 
399
        res = _mod_ui.bool_from_string(s, accepted_values=accepted_values)
 
400
        self.assertEquals(False, res)
 
401
 
 
402
    def assertIsNone(self, s, accepted_values=None):
 
403
        res = _mod_ui.bool_from_string(s, accepted_values=accepted_values)
 
404
        self.assertIs(None, res)
 
405
 
 
406
    def test_know_valid_values(self):
 
407
        self.assertIsTrue('true')
 
408
        self.assertIsFalse('false')
 
409
        self.assertIsTrue('1')
 
410
        self.assertIsFalse('0')
 
411
        self.assertIsTrue('on')
 
412
        self.assertIsFalse('off')
 
413
        self.assertIsTrue('yes')
 
414
        self.assertIsFalse('no')
 
415
        self.assertIsTrue('y')
 
416
        self.assertIsFalse('n')
 
417
        # Also try some case variations
 
418
        self.assertIsTrue('True')
 
419
        self.assertIsFalse('False')
 
420
        self.assertIsTrue('On')
 
421
        self.assertIsFalse('Off')
 
422
        self.assertIsTrue('ON')
 
423
        self.assertIsFalse('OFF')
 
424
        self.assertIsTrue('oN')
 
425
        self.assertIsFalse('oFf')
 
426
 
 
427
    def test_invalid_values(self):
 
428
        self.assertIsNone(None)
 
429
        self.assertIsNone('doubt')
 
430
        self.assertIsNone('frue')
 
431
        self.assertIsNone('talse')
 
432
        self.assertIsNone('42')
 
433
 
 
434
    def test_provided_values(self):
 
435
        av = dict(y=True, n=False, yes=True, no=False)
 
436
        self.assertIsTrue('y', av)
 
437
        self.assertIsTrue('Y', av)
 
438
        self.assertIsTrue('Yes', av)
 
439
        self.assertIsFalse('n', av)
 
440
        self.assertIsFalse('N', av)
 
441
        self.assertIsFalse('No', av)
 
442
        self.assertIsNone('1', av)
 
443
        self.assertIsNone('0', av)
 
444
        self.assertIsNone('on', av)
 
445
        self.assertIsNone('off', av)