← 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: 2012-01-24 13:14:06 UTC
  • mto: (6445.4.5 nested-trees-spec)
  • mto: This revision was merged to the branch mainline in revision 6518.
  • Revision ID: jelmer@samba.org-20120124131406-wedftkorbpv37bm0
Import nested tree doc from devnotes.

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
27
    config,
28
 
    errors,
29
28
    remote,
30
 
    repository,
31
29
    tests,
32
30
    ui as _mod_ui,
33
31
    )
34
 
from bzrlib.symbol_versioning import (
35
 
    deprecated_in,
36
 
    )
37
32
from bzrlib.tests import (
38
33
    fixtures,
39
34
    test_progress,
40
35
    )
41
36
from bzrlib.ui import text as _mod_ui_text
 
37
from bzrlib.tests.testui import (
 
38
    ProgressRecordingUIFactory,
 
39
    )
42
40
 
43
41
 
44
42
class TestUIConfiguration(tests.TestCaseWithTransport):
50
48
        ui = tests.TestUIFactory(stdin=None,
51
49
            stdout=tests.StringIOWrapper(),
52
50
            stderr=tests.StringIOWrapper())
53
 
        os = ui.make_output_stream()
54
 
        self.assertEquals(os.encoding, enc)
 
51
        output = ui.make_output_stream()
 
52
        self.assertEquals(output.encoding, enc)
55
53
 
56
54
 
57
55
class TestTextUIFactory(tests.TestCase):
58
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
 
59
71
    def test_text_factory_ascii_password(self):
60
 
        ui = tests.TestUIFactory(stdin='secret\n',
61
 
                                 stdout=tests.StringIOWrapper(),
62
 
                                 stderr=tests.StringIOWrapper())
 
72
        ui = self.make_test_ui_factory('secret\n')
63
73
        pb = ui.nested_progress_bar()
64
74
        try:
65
75
            self.assertEqual('secret',
80
90
        We can't predict what encoding users will have for stdin, so we force
81
91
        it to utf8 to test that we transport the password correctly.
82
92
        """
83
 
        ui = tests.TestUIFactory(stdin=u'baz\u1234'.encode('utf8'),
84
 
                                 stdout=tests.StringIOWrapper(),
85
 
                                 stderr=tests.StringIOWrapper())
 
93
        ui = self.make_test_ui_factory(u'baz\u1234'.encode('utf8'))
86
94
        ui.stderr.encoding = ui.stdout.encoding = ui.stdin.encoding = 'utf8'
87
95
        pb = ui.nested_progress_bar()
88
96
        try:
103
111
    def test_text_ui_get_boolean(self):
104
112
        stdin = tests.StringIOWrapper("y\n" # True
105
113
                                      "n\n" # False
 
114
                                      " \n y \n" # True
 
115
                                      " no \n" # False
106
116
                                      "yes with garbage\nY\n" # True
107
117
                                      "not an answer\nno\n" # False
108
118
                                      "I'm sure!\nyes\n" # True
111
121
        stdout = tests.StringIOWrapper()
112
122
        stderr = tests.StringIOWrapper()
113
123
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
114
 
        self.assertEqual(True, factory.get_boolean(""))
115
 
        self.assertEqual(False, factory.get_boolean(""))
116
 
        self.assertEqual(True, factory.get_boolean(""))
117
 
        self.assertEqual(False, factory.get_boolean(""))
118
 
        self.assertEqual(True, factory.get_boolean(""))
119
 
        self.assertEqual(False, factory.get_boolean(""))
120
 
        self.assertEqual("foo\n", factory.stdin.read())
121
 
        # stdin should be empty
122
 
        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())
123
201
 
124
202
    def test_text_ui_get_integer(self):
125
203
        stdin = tests.StringIOWrapper(
129
207
        stdout = tests.StringIOWrapper()
130
208
        stderr = tests.StringIOWrapper()
131
209
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
132
 
        self.assertEqual(1, factory.get_integer(""))
133
 
        self.assertEqual(-2, factory.get_integer(""))
134
 
        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""))
135
213
 
136
214
    def test_text_factory_prompt(self):
137
215
        # see <https://launchpad.net/bugs/365891>
138
216
        StringIO = tests.StringIOWrapper
139
217
        factory = _mod_ui_text.TextUIFactory(StringIO(), StringIO(), StringIO())
140
 
        factory.prompt('foo %2e')
 
218
        factory.prompt(u'foo %2e')
141
219
        self.assertEqual('', factory.stdout.getvalue())
142
220
        self.assertEqual('foo %2e', factory.stderr.getvalue())
143
221
 
144
222
    def test_text_factory_prompts_and_clears(self):
145
223
        # a get_boolean call should clear the pb before prompting
146
224
        out = test_progress._TTYStringIO()
147
 
        os.environ['TERM'] = 'xterm'
 
225
        self.overrideEnv('TERM', 'xterm')
148
226
        factory = _mod_ui_text.TextUIFactory(
149
227
            stdin=tests.StringIOWrapper("yada\ny\n"),
150
228
            stdout=out, stderr=out)
158
236
                         self.apply_redirected(None, factory.stdout,
159
237
                                               factory.stdout,
160
238
                                               factory.get_boolean,
161
 
                                               "what do you want"))
 
239
                                               u"what do you want"))
162
240
        output = out.getvalue()
163
241
        self.assertContainsRe(output,
164
242
            "| foo *\r\r  *\r*")
165
 
        self.assertContainsRe(output,
166
 
            r"what do you want\? \[y/n\]: what do you want\? \[y/n\]: ")
 
243
        self.assertContainsString(output,
 
244
            r"what do you want? ([y]es, [n]o): what do you want? ([y]es, [n]o): ")
167
245
        # stdin should have been totally consumed
168
246
        self.assertEqual('', factory.stdin.readline())
169
247
 
187
265
        factory.stdout.encoding = "utf8"
188
266
        # there is no output from the base factory
189
267
        self.assertEqual("someuser",
190
 
                         factory.get_username('Hello %(host)s', host='some'))
 
268
                         factory.get_username(u'Hello %(host)s', host='some'))
191
269
        self.assertEquals("Hello some: ", factory.stderr.getvalue())
192
270
        self.assertEquals('', factory.stdout.getvalue())
193
 
        self.assertEqual("", factory.get_username("Gebruiker"))
 
271
        self.assertEqual("", factory.get_username(u"Gebruiker"))
194
272
        # stdin should be empty
195
273
        self.assertEqual('', factory.stdin.readline())
196
274
 
212
290
            pb.finished()
213
291
 
214
292
    def test_quietness(self):
215
 
        os.environ['BZR_PROGRESS_BAR'] = 'text'
 
293
        self.overrideEnv('BZR_PROGRESS_BAR', 'text')
216
294
        ui_factory = _mod_ui_text.TextUIFactory(None,
217
295
            test_progress._TTYStringIO(),
218
296
            test_progress._TTYStringIO())
224
302
 
225
303
    def test_text_ui_show_user_warning(self):
226
304
        from bzrlib.repofmt.groupcompress_repo import RepositoryFormat2a
227
 
        from bzrlib.repofmt.pack_repo import RepositoryFormatKnitPack5
 
305
        from bzrlib.repofmt.knitpack_repo import RepositoryFormatKnitPack5
228
306
        err = StringIO()
229
307
        out = StringIO()
230
308
        ui = tests.TextUIFactory(stdin=None, stdout=out, stderr=err)
299
377
            # however, it can still be forced on
300
378
            (FileStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),
301
379
            ):
302
 
            os.environ['TERM'] = term
303
 
            if pb is None:
304
 
                if 'BZR_PROGRESS_BAR' in os.environ:
305
 
                    del os.environ['BZR_PROGRESS_BAR']
306
 
            else:
307
 
                os.environ['BZR_PROGRESS_BAR'] = pb
 
380
            self.overrideEnv('TERM', term)
 
381
            self.overrideEnv('BZR_PROGRESS_BAR', pb)
308
382
            stdin = file_class('')
309
383
            stderr = file_class()
310
384
            stdout = file_class()
321
395
        stderr = test_progress._NonTTYStringIO()
322
396
        stdout = test_progress._NonTTYStringIO()
323
397
        for term_type in ['dumb', None, 'xterm']:
324
 
            if term_type is None:
325
 
                del os.environ['TERM']
326
 
            else:
327
 
                os.environ['TERM'] = term_type
 
398
            self.overrideEnv('TERM', term_type)
328
399
            uif = _mod_ui.make_ui_for_terminal(stdin, stdout, stderr)
329
400
            self.assertIsInstance(uif, _mod_ui_text.TextUIFactory,
330
401
                'TERM=%r' % (term_type,))
351
422
        self.assertRaises(
352
423
            NotImplementedError,
353
424
            self.apply_redirected,
354
 
            None, stdout, stdout, factory.get_boolean, "foo")
 
425
            None, stdout, stdout, factory.get_boolean, u"foo")
355
426
 
356
427
 
357
428
class TestUIFactoryTests(tests.TestCase):
370
441
 
371
442
    def test_canned_input_get_input(self):
372
443
        uif = _mod_ui.CannedInputUIFactory([True, 'mbp', 'password', 42])
373
 
        self.assertEqual(True, uif.get_boolean('Extra cheese?'))
374
 
        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'))
375
446
        self.assertEqual('password',
376
 
                         uif.get_password('Password for %(host)s',
 
447
                         uif.get_password(u'Password for %(host)s',
377
448
                                          host='example.com'))
378
 
        self.assertEqual(42, uif.get_integer('And all that jazz ?'))
 
449
        self.assertEqual(42, uif.get_integer(u'And all that jazz ?'))
379
450
 
380
451
 
381
452
class TestBoolFromString(tests.TestCase):
432
503
        self.assertIsNone('0', av)
433
504
        self.assertIsNone('on', av)
434
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)