← 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: Jelmer Vernooij
  • Date: 2011-12-19 10:58:39 UTC
  • mfrom: (6383 +trunk)
  • mto: This revision was merged to the branch mainline in revision 6386.
  • Revision ID: jelmer@canonical.com-20111219105839-uji05ck4rkm1mj4j
Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_ui.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
17
17
"""Tests for the bzrlib ui
18
18
"""
19
19
 
20
 
import os
21
 
import re
22
20
import time
23
21
 
24
22
from StringIO import StringIO
25
23
 
 
24
from testtools.matchers import *
 
25
 
26
26
from bzrlib import (
27
 
    errors,
 
27
    config,
28
28
    remote,
29
 
    repository,
30
29
    tests,
31
30
    ui as _mod_ui,
32
31
    )
33
 
from bzrlib.symbol_versioning import (
34
 
    deprecated_in,
 
32
from bzrlib.tests import (
 
33
    fixtures,
 
34
    test_progress,
35
35
    )
36
 
from bzrlib.tests import test_progress
37
36
from bzrlib.ui import text as _mod_ui_text
 
37
from bzrlib.tests.testui import (
 
38
    ProgressRecordingUIFactory,
 
39
    )
 
40
 
 
41
 
 
42
class TestUIConfiguration(tests.TestCaseWithTransport):
 
43
 
 
44
    def test_output_encoding_configuration(self):
 
45
        enc = fixtures.generate_unicode_encodings().next()
 
46
        config.GlobalConfig().set_user_option('output_encoding',
 
47
            enc)
 
48
        ui = tests.TestUIFactory(stdin=None,
 
49
            stdout=tests.StringIOWrapper(),
 
50
            stderr=tests.StringIOWrapper())
 
51
        output = ui.make_output_stream()
 
52
        self.assertEquals(output.encoding, enc)
38
53
 
39
54
 
40
55
class TestTextUIFactory(tests.TestCase):
41
56
 
 
57
    def make_test_ui_factory(self, stdin_contents):
 
58
        ui = tests.TestUIFactory(stdin=stdin_contents,
 
59
                                 stdout=tests.StringIOWrapper(),
 
60
                                 stderr=tests.StringIOWrapper())
 
61
        return ui
 
62
 
 
63
    def test_text_factory_confirm(self):
 
64
        # turns into reading a regular boolean
 
65
        ui = self.make_test_ui_factory('n\n')
 
66
        self.assertEquals(ui.confirm_action(u'Should %(thing)s pass?',
 
67
            'bzrlib.tests.test_ui.confirmation',
 
68
            {'thing': 'this'},),
 
69
            False)
 
70
 
42
71
    def test_text_factory_ascii_password(self):
43
 
        ui = tests.TestUIFactory(stdin='secret\n',
44
 
                                 stdout=tests.StringIOWrapper(),
45
 
                                 stderr=tests.StringIOWrapper())
 
72
        ui = self.make_test_ui_factory('secret\n')
46
73
        pb = ui.nested_progress_bar()
47
74
        try:
48
75
            self.assertEqual('secret',
63
90
        We can't predict what encoding users will have for stdin, so we force
64
91
        it to utf8 to test that we transport the password correctly.
65
92
        """
66
 
        ui = tests.TestUIFactory(stdin=u'baz\u1234'.encode('utf8'),
67
 
                                 stdout=tests.StringIOWrapper(),
68
 
                                 stderr=tests.StringIOWrapper())
 
93
        ui = self.make_test_ui_factory(u'baz\u1234'.encode('utf8'))
69
94
        ui.stderr.encoding = ui.stdout.encoding = ui.stdin.encoding = 'utf8'
70
95
        pb = ui.nested_progress_bar()
71
96
        try:
83
108
        finally:
84
109
            pb.finished()
85
110
 
86
 
    def test_progress_note(self):
87
 
        stderr = tests.StringIOWrapper()
88
 
        stdout = tests.StringIOWrapper()
89
 
        ui_factory = _mod_ui_text.TextUIFactory(stdin=tests.StringIOWrapper(''),
90
 
                                                stderr=stderr,
91
 
                                                stdout=stdout)
92
 
        pb = ui_factory.nested_progress_bar()
93
 
        try:
94
 
            result = self.applyDeprecated(deprecated_in((2, 1, 0)),
95
 
                pb.note,
96
 
                't')
97
 
            self.assertEqual(None, result)
98
 
            self.assertEqual("t\n", stdout.getvalue())
99
 
            # Since there was no update() call, there should be no clear() call
100
 
            self.failIf(re.search(r'^\r {10,}\r$',
101
 
                                  stderr.getvalue()) is not None,
102
 
                        'We cleared the stderr without anything to put there')
103
 
        finally:
104
 
            pb.finished()
105
 
 
106
 
    def test_progress_note_clears(self):
107
 
        stderr = test_progress._TTYStringIO()
108
 
        stdout = test_progress._TTYStringIO()
109
 
        # so that we get a TextProgressBar
110
 
        os.environ['TERM'] = 'xterm'
111
 
        ui_factory = _mod_ui_text.TextUIFactory(
112
 
            stdin=tests.StringIOWrapper(''),
113
 
            stdout=stdout, stderr=stderr)
114
 
        self.assertIsInstance(ui_factory._progress_view,
115
 
                              _mod_ui_text.TextProgressView)
116
 
        pb = ui_factory.nested_progress_bar()
117
 
        try:
118
 
            # Create a progress update that isn't throttled
119
 
            pb.update('x', 1, 1)
120
 
            result = self.applyDeprecated(deprecated_in((2, 1, 0)),
121
 
                pb.note, 't')
122
 
            self.assertEqual(None, result)
123
 
            self.assertEqual("t\n", stdout.getvalue())
124
 
            # the exact contents will depend on the terminal width and we don't
125
 
            # care about that right now - but you're probably running it on at
126
 
            # least a 10-character wide terminal :)
127
 
            self.assertContainsRe(stderr.getvalue(), r'\r {10,}\r$')
128
 
        finally:
129
 
            pb.finished()
130
 
 
131
111
    def test_text_ui_get_boolean(self):
132
112
        stdin = tests.StringIOWrapper("y\n" # True
133
113
                                      "n\n" # False
 
114
                                      " \n y \n" # True
 
115
                                      " no \n" # False
134
116
                                      "yes with garbage\nY\n" # True
135
117
                                      "not an answer\nno\n" # False
136
118
                                      "I'm sure!\nyes\n" # True
139
121
        stdout = tests.StringIOWrapper()
140
122
        stderr = tests.StringIOWrapper()
141
123
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
142
 
        self.assertEqual(True, factory.get_boolean(""))
143
 
        self.assertEqual(False, factory.get_boolean(""))
144
 
        self.assertEqual(True, factory.get_boolean(""))
145
 
        self.assertEqual(False, factory.get_boolean(""))
146
 
        self.assertEqual(True, factory.get_boolean(""))
147
 
        self.assertEqual(False, factory.get_boolean(""))
148
 
        self.assertEqual("foo\n", factory.stdin.read())
149
 
        # stdin should be empty
150
 
        self.assertEqual('', factory.stdin.readline())
 
124
        self.assertEqual(True, factory.get_boolean(u""))
 
125
        self.assertEqual(False, factory.get_boolean(u""))
 
126
        self.assertEqual(True, factory.get_boolean(u""))
 
127
        self.assertEqual(False, factory.get_boolean(u""))
 
128
        self.assertEqual(True, factory.get_boolean(u""))
 
129
        self.assertEqual(False, factory.get_boolean(u""))
 
130
        self.assertEqual(True, factory.get_boolean(u""))
 
131
        self.assertEqual(False, factory.get_boolean(u""))
 
132
        self.assertEqual("foo\n", factory.stdin.read())
 
133
        # stdin should be empty
 
134
        self.assertEqual('', factory.stdin.readline())
 
135
        # return false on EOF
 
136
        self.assertEqual(False, factory.get_boolean(u""))
 
137
 
 
138
    def test_text_ui_choose_bad_parameters(self):
 
139
        stdin = tests.StringIOWrapper()
 
140
        stdout = tests.StringIOWrapper()
 
141
        stderr = tests.StringIOWrapper()
 
142
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
 
143
        # invalid default index
 
144
        self.assertRaises(ValueError, factory.choose, u"", u"&Yes\n&No", 3)
 
145
        # duplicated choice
 
146
        self.assertRaises(ValueError, factory.choose, u"", u"&choice\n&ChOiCe")
 
147
        # duplicated shortcut
 
148
        self.assertRaises(ValueError, factory.choose, u"", u"&choice1\nchoi&ce2")
 
149
 
 
150
    def test_text_ui_choose_prompt(self):
 
151
        stdin = tests.StringIOWrapper()
 
152
        stdout = tests.StringIOWrapper()
 
153
        stderr = tests.StringIOWrapper()
 
154
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
 
155
        # choices with explicit shortcuts
 
156
        factory.choose(u"prompt", u"&yes\n&No\nmore &info")
 
157
        self.assertEqual("prompt ([y]es, [N]o, more [i]nfo): \n", factory.stderr.getvalue())
 
158
        # automatic shortcuts
 
159
        factory.stderr.truncate(0)
 
160
        factory.choose(u"prompt", u"yes\nNo\nmore info")
 
161
        self.assertEqual("prompt ([y]es, [N]o, [m]ore info): \n", factory.stderr.getvalue())
 
162
 
 
163
    def test_text_ui_choose_return_values(self):
 
164
        choose = lambda: factory.choose(u"", u"&Yes\n&No\nMaybe\nmore &info", 3)
 
165
        stdin = tests.StringIOWrapper("y\n" # 0
 
166
                                      "n\n" # 1
 
167
                                      " \n" # default: 3
 
168
                                      " no \n" # 1
 
169
                                      "b\na\nd \n" # bad shortcuts, all ignored
 
170
                                      "yes with garbage\nY\n" # 0
 
171
                                      "not an answer\nno\n" # 1
 
172
                                      "info\nmore info\n" # 3
 
173
                                      "Maybe\n" # 2
 
174
                                      "foo\n")
 
175
        stdout = tests.StringIOWrapper()
 
176
        stderr = tests.StringIOWrapper()
 
177
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
 
178
        self.assertEqual(0, choose())
 
179
        self.assertEqual(1, choose())
 
180
        self.assertEqual(3, choose())
 
181
        self.assertEqual(1, choose())
 
182
        self.assertEqual(0, choose())
 
183
        self.assertEqual(1, choose())
 
184
        self.assertEqual(3, choose())
 
185
        self.assertEqual(2, choose())
 
186
        self.assertEqual("foo\n", factory.stdin.read())
 
187
        # stdin should be empty
 
188
        self.assertEqual('', factory.stdin.readline())
 
189
        # return None on EOF
 
190
        self.assertEqual(None, choose())
 
191
 
 
192
    def test_text_ui_choose_no_default(self):
 
193
        stdin = tests.StringIOWrapper(" \n" # no default, invalid!
 
194
                                      " yes \n" # 0
 
195
                                      "foo\n")
 
196
        stdout = tests.StringIOWrapper()
 
197
        stderr = tests.StringIOWrapper()
 
198
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
 
199
        self.assertEqual(0, factory.choose(u"", u"&Yes\n&No"))
 
200
        self.assertEqual("foo\n", factory.stdin.read())
151
201
 
152
202
    def test_text_ui_get_integer(self):
153
203
        stdin = tests.StringIOWrapper(
157
207
        stdout = tests.StringIOWrapper()
158
208
        stderr = tests.StringIOWrapper()
159
209
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
160
 
        self.assertEqual(1, factory.get_integer(""))
161
 
        self.assertEqual(-2, factory.get_integer(""))
162
 
        self.assertEqual(42, factory.get_integer(""))
 
210
        self.assertEqual(1, factory.get_integer(u""))
 
211
        self.assertEqual(-2, factory.get_integer(u""))
 
212
        self.assertEqual(42, factory.get_integer(u""))
163
213
 
164
214
    def test_text_factory_prompt(self):
165
215
        # see <https://launchpad.net/bugs/365891>
166
216
        StringIO = tests.StringIOWrapper
167
217
        factory = _mod_ui_text.TextUIFactory(StringIO(), StringIO(), StringIO())
168
 
        factory.prompt('foo %2e')
 
218
        factory.prompt(u'foo %2e')
169
219
        self.assertEqual('', factory.stdout.getvalue())
170
220
        self.assertEqual('foo %2e', factory.stderr.getvalue())
171
221
 
172
222
    def test_text_factory_prompts_and_clears(self):
173
223
        # a get_boolean call should clear the pb before prompting
174
224
        out = test_progress._TTYStringIO()
175
 
        os.environ['TERM'] = 'xterm'
 
225
        self.overrideEnv('TERM', 'xterm')
176
226
        factory = _mod_ui_text.TextUIFactory(
177
227
            stdin=tests.StringIOWrapper("yada\ny\n"),
178
228
            stdout=out, stderr=out)
 
229
        factory._avail_width = lambda: 79
179
230
        pb = factory.nested_progress_bar()
180
231
        pb.show_bar = False
181
232
        pb.show_spinner = False
185
236
                         self.apply_redirected(None, factory.stdout,
186
237
                                               factory.stdout,
187
238
                                               factory.get_boolean,
188
 
                                               "what do you want"))
 
239
                                               u"what do you want"))
189
240
        output = out.getvalue()
190
 
        self.assertContainsRe(factory.stdout.getvalue(),
191
 
            "foo *\r\r  *\r*")
192
 
        self.assertContainsRe(factory.stdout.getvalue(),
193
 
            r"what do you want\? \[y/n\]: what do you want\? \[y/n\]: ")
 
241
        self.assertContainsRe(output,
 
242
            "| foo *\r\r  *\r*")
 
243
        self.assertContainsString(output,
 
244
            r"what do you want? ([y]es, [n]o): what do you want? ([y]es, [n]o): ")
194
245
        # stdin should have been totally consumed
195
246
        self.assertEqual('', factory.stdin.readline())
196
247
 
214
265
        factory.stdout.encoding = "utf8"
215
266
        # there is no output from the base factory
216
267
        self.assertEqual("someuser",
217
 
                         factory.get_username('Hello %(host)s', host='some'))
 
268
                         factory.get_username(u'Hello %(host)s', host='some'))
218
269
        self.assertEquals("Hello some: ", factory.stderr.getvalue())
219
270
        self.assertEquals('', factory.stdout.getvalue())
220
 
        self.assertEqual("", factory.get_username("Gebruiker"))
 
271
        self.assertEqual("", factory.get_username(u"Gebruiker"))
221
272
        # stdin should be empty
222
273
        self.assertEqual('', factory.stdin.readline())
223
274
 
239
290
            pb.finished()
240
291
 
241
292
    def test_quietness(self):
242
 
        os.environ['BZR_PROGRESS_BAR'] = 'text'
 
293
        self.overrideEnv('BZR_PROGRESS_BAR', 'text')
243
294
        ui_factory = _mod_ui_text.TextUIFactory(None,
244
295
            test_progress._TTYStringIO(),
245
296
            test_progress._TTYStringIO())
251
302
 
252
303
    def test_text_ui_show_user_warning(self):
253
304
        from bzrlib.repofmt.groupcompress_repo import RepositoryFormat2a
254
 
        from bzrlib.repofmt.pack_repo import RepositoryFormatKnitPack5
 
305
        from bzrlib.repofmt.knitpack_repo import RepositoryFormatKnitPack5
255
306
        err = StringIO()
256
307
        out = StringIO()
257
308
        ui = tests.TextUIFactory(stdin=None, stdout=out, stderr=err)
326
377
            # however, it can still be forced on
327
378
            (FileStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),
328
379
            ):
329
 
            os.environ['TERM'] = term
330
 
            if pb is None:
331
 
                if 'BZR_PROGRESS_BAR' in os.environ:
332
 
                    del os.environ['BZR_PROGRESS_BAR']
333
 
            else:
334
 
                os.environ['BZR_PROGRESS_BAR'] = pb
 
380
            self.overrideEnv('TERM', term)
 
381
            self.overrideEnv('BZR_PROGRESS_BAR', pb)
335
382
            stdin = file_class('')
336
383
            stderr = file_class()
337
384
            stdout = file_class()
348
395
        stderr = test_progress._NonTTYStringIO()
349
396
        stdout = test_progress._NonTTYStringIO()
350
397
        for term_type in ['dumb', None, 'xterm']:
351
 
            if term_type is None:
352
 
                del os.environ['TERM']
353
 
            else:
354
 
                os.environ['TERM'] = term_type
 
398
            self.overrideEnv('TERM', term_type)
355
399
            uif = _mod_ui.make_ui_for_terminal(stdin, stdout, stderr)
356
400
            self.assertIsInstance(uif, _mod_ui_text.TextUIFactory,
357
401
                'TERM=%r' % (term_type,))
378
422
        self.assertRaises(
379
423
            NotImplementedError,
380
424
            self.apply_redirected,
381
 
            None, stdout, stdout, factory.get_boolean, "foo")
 
425
            None, stdout, stdout, factory.get_boolean, u"foo")
382
426
 
383
427
 
384
428
class TestUIFactoryTests(tests.TestCase):
385
429
 
386
430
    def test_test_ui_factory_progress(self):
387
431
        # there's no output; we just want to make sure this doesn't crash -
388
 
        # see https://bugs.edge.launchpad.net/bzr/+bug/408201
 
432
        # see https://bugs.launchpad.net/bzr/+bug/408201
389
433
        ui = tests.TestUIFactory()
390
434
        pb = ui.nested_progress_bar()
391
435
        pb.update('hello')
397
441
 
398
442
    def test_canned_input_get_input(self):
399
443
        uif = _mod_ui.CannedInputUIFactory([True, 'mbp', 'password', 42])
400
 
        self.assertEqual(True, uif.get_boolean('Extra cheese?'))
401
 
        self.assertEqual('mbp', uif.get_username('Enter your user name'))
 
444
        self.assertEqual(True, uif.get_boolean(u'Extra cheese?'))
 
445
        self.assertEqual('mbp', uif.get_username(u'Enter your user name'))
402
446
        self.assertEqual('password',
403
 
                         uif.get_password('Password for %(host)s',
 
447
                         uif.get_password(u'Password for %(host)s',
404
448
                                          host='example.com'))
405
 
        self.assertEqual(42, uif.get_integer('And all that jazz ?'))
 
449
        self.assertEqual(42, uif.get_integer(u'And all that jazz ?'))
406
450
 
407
451
 
408
452
class TestBoolFromString(tests.TestCase):
459
503
        self.assertIsNone('0', av)
460
504
        self.assertIsNone('on', av)
461
505
        self.assertIsNone('off', av)
 
506
 
 
507
 
 
508
class TestConfirmationUserInterfacePolicy(tests.TestCase):
 
509
 
 
510
    def test_confirm_action_default(self):
 
511
        base_ui = _mod_ui.NoninteractiveUIFactory()
 
512
        for answer in [True, False]:
 
513
            self.assertEquals(
 
514
                _mod_ui.ConfirmationUserInterfacePolicy(base_ui, answer, {})
 
515
                .confirm_action("Do something?",
 
516
                    "bzrlib.tests.do_something", {}),
 
517
                answer)
 
518
 
 
519
    def test_confirm_action_specific(self):
 
520
        base_ui = _mod_ui.NoninteractiveUIFactory()
 
521
        for default_answer in [True, False]:
 
522
            for specific_answer in [True, False]:
 
523
                for conf_id in ['given_id', 'other_id']:
 
524
                    wrapper = _mod_ui.ConfirmationUserInterfacePolicy(
 
525
                        base_ui, default_answer, dict(given_id=specific_answer))
 
526
                    result = wrapper.confirm_action("Do something?", conf_id, {})
 
527
                    if conf_id == 'given_id':
 
528
                        self.assertEquals(result, specific_answer)
 
529
                    else:
 
530
                        self.assertEquals(result, default_answer)
 
531
 
 
532
    def test_repr(self):
 
533
        base_ui = _mod_ui.NoninteractiveUIFactory()
 
534
        wrapper = _mod_ui.ConfirmationUserInterfacePolicy(
 
535
            base_ui, True, dict(a=2))
 
536
        self.assertThat(repr(wrapper),
 
537
            Equals("ConfirmationUserInterfacePolicy("
 
538
                "NoninteractiveUIFactory(), True, {'a': 2})"))
 
539
 
 
540
 
 
541
class TestProgressRecordingUI(tests.TestCase):
 
542
    """Test test-oriented UIFactory that records progress updates"""
 
543
 
 
544
    def test_nested_ignore_depth_beyond_one(self):
 
545
        # we only want to capture the first level out progress, not
 
546
        # want sub-components might do. So we have nested bars ignored.
 
547
        factory = ProgressRecordingUIFactory()
 
548
        pb1 = factory.nested_progress_bar()
 
549
        pb1.update('foo', 0, 1)
 
550
        pb2 = factory.nested_progress_bar()
 
551
        pb2.update('foo', 0, 1)
 
552
        pb2.finished()
 
553
        pb1.finished()
 
554
        self.assertEqual([("update", 0, 1, 'foo')], factory._calls)