← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_ui.py

(jelmer) Use the absolute_import feature everywhere in bzrlib,
 and add a source test to make sure it's used everywhere. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

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