← 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: John Arbash Meinel
  • Date: 2010-07-13 07:44:02 UTC
  • mto: This revision was merged to the branch mainline in revision 5342.
  • Revision ID: john@arbash-meinel.com-20100713074402-wp3oh7cyx76fkvmm
Bump trunk to 2.3-dev1

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_ui.py
18
18
"""
19
19
 
20
20
import os
 
21
import re
21
22
import time
22
23
 
23
24
from StringIO import StringIO
24
25
 
25
 
from testtools.matchers import *
26
 
 
27
26
from bzrlib import (
28
27
    config,
29
28
    errors,
40
39
    test_progress,
41
40
    )
42
41
from bzrlib.ui import text as _mod_ui_text
43
 
from bzrlib.tests.testui import (
44
 
    ProgressRecordingUIFactory,
45
 
    )
46
42
 
47
43
 
48
44
class TestUIConfiguration(tests.TestCaseWithTransport):
54
50
        ui = tests.TestUIFactory(stdin=None,
55
51
            stdout=tests.StringIOWrapper(),
56
52
            stderr=tests.StringIOWrapper())
57
 
        output = ui.make_output_stream()
58
 
        self.assertEquals(output.encoding, enc)
 
53
        os = ui.make_output_stream()
 
54
        self.assertEquals(os.encoding, enc)
59
55
 
60
56
 
61
57
class TestTextUIFactory(tests.TestCase):
62
58
 
63
 
    def make_test_ui_factory(self, stdin_contents):
64
 
        ui = tests.TestUIFactory(stdin=stdin_contents,
65
 
                                 stdout=tests.StringIOWrapper(),
66
 
                                 stderr=tests.StringIOWrapper())
67
 
        return ui
68
 
 
69
 
    def test_text_factory_confirm(self):
70
 
        # turns into reading a regular boolean
71
 
        ui = self.make_test_ui_factory('n\n')
72
 
        self.assertEquals(ui.confirm_action('Should %(thing)s pass?',
73
 
            'bzrlib.tests.test_ui.confirmation',
74
 
            {'thing': 'this'},),
75
 
            False)
76
 
 
77
59
    def test_text_factory_ascii_password(self):
78
 
        ui = self.make_test_ui_factory('secret\n')
 
60
        ui = tests.TestUIFactory(stdin='secret\n',
 
61
                                 stdout=tests.StringIOWrapper(),
 
62
                                 stderr=tests.StringIOWrapper())
79
63
        pb = ui.nested_progress_bar()
80
64
        try:
81
65
            self.assertEqual('secret',
96
80
        We can't predict what encoding users will have for stdin, so we force
97
81
        it to utf8 to test that we transport the password correctly.
98
82
        """
99
 
        ui = self.make_test_ui_factory(u'baz\u1234'.encode('utf8'))
 
83
        ui = tests.TestUIFactory(stdin=u'baz\u1234'.encode('utf8'),
 
84
                                 stdout=tests.StringIOWrapper(),
 
85
                                 stderr=tests.StringIOWrapper())
100
86
        ui.stderr.encoding = ui.stdout.encoding = ui.stdin.encoding = 'utf8'
101
87
        pb = ui.nested_progress_bar()
102
88
        try:
114
100
        finally:
115
101
            pb.finished()
116
102
 
 
103
    def test_progress_note(self):
 
104
        stderr = tests.StringIOWrapper()
 
105
        stdout = tests.StringIOWrapper()
 
106
        ui_factory = _mod_ui_text.TextUIFactory(stdin=tests.StringIOWrapper(''),
 
107
                                                stderr=stderr,
 
108
                                                stdout=stdout)
 
109
        pb = ui_factory.nested_progress_bar()
 
110
        try:
 
111
            result = self.applyDeprecated(deprecated_in((2, 1, 0)),
 
112
                pb.note,
 
113
                't')
 
114
            self.assertEqual(None, result)
 
115
            self.assertEqual("t\n", stdout.getvalue())
 
116
            # Since there was no update() call, there should be no clear() call
 
117
            self.failIf(re.search(r'^\r {10,}\r$',
 
118
                                  stderr.getvalue()) is not None,
 
119
                        'We cleared the stderr without anything to put there')
 
120
        finally:
 
121
            pb.finished()
 
122
 
 
123
    def test_progress_note_clears(self):
 
124
        stderr = test_progress._TTYStringIO()
 
125
        stdout = test_progress._TTYStringIO()
 
126
        # so that we get a TextProgressBar
 
127
        os.environ['TERM'] = 'xterm'
 
128
        ui_factory = _mod_ui_text.TextUIFactory(
 
129
            stdin=tests.StringIOWrapper(''),
 
130
            stdout=stdout, stderr=stderr)
 
131
        self.assertIsInstance(ui_factory._progress_view,
 
132
                              _mod_ui_text.TextProgressView)
 
133
        pb = ui_factory.nested_progress_bar()
 
134
        try:
 
135
            # Create a progress update that isn't throttled
 
136
            pb.update('x', 1, 1)
 
137
            result = self.applyDeprecated(deprecated_in((2, 1, 0)),
 
138
                pb.note, 't')
 
139
            self.assertEqual(None, result)
 
140
            self.assertEqual("t\n", stdout.getvalue())
 
141
            # the exact contents will depend on the terminal width and we don't
 
142
            # care about that right now - but you're probably running it on at
 
143
            # least a 10-character wide terminal :)
 
144
            self.assertContainsRe(stderr.getvalue(), r'\r {10,}\r$')
 
145
        finally:
 
146
            pb.finished()
 
147
 
117
148
    def test_text_ui_get_boolean(self):
118
149
        stdin = tests.StringIOWrapper("y\n" # True
119
150
                                      "n\n" # False
158
189
    def test_text_factory_prompts_and_clears(self):
159
190
        # a get_boolean call should clear the pb before prompting
160
191
        out = test_progress._TTYStringIO()
161
 
        self.overrideEnv('TERM', 'xterm')
 
192
        os.environ['TERM'] = 'xterm'
162
193
        factory = _mod_ui_text.TextUIFactory(
163
194
            stdin=tests.StringIOWrapper("yada\ny\n"),
164
195
            stdout=out, stderr=out)
165
 
        factory._avail_width = lambda: 79
166
196
        pb = factory.nested_progress_bar()
167
197
        pb.show_bar = False
168
198
        pb.show_spinner = False
174
204
                                               factory.get_boolean,
175
205
                                               "what do you want"))
176
206
        output = out.getvalue()
177
 
        self.assertContainsRe(output,
178
 
            "| foo *\r\r  *\r*")
179
 
        self.assertContainsRe(output,
 
207
        self.assertContainsRe(factory.stdout.getvalue(),
 
208
            "foo *\r\r  *\r*")
 
209
        self.assertContainsRe(factory.stdout.getvalue(),
180
210
            r"what do you want\? \[y/n\]: what do you want\? \[y/n\]: ")
181
211
        # stdin should have been totally consumed
182
212
        self.assertEqual('', factory.stdin.readline())
226
256
            pb.finished()
227
257
 
228
258
    def test_quietness(self):
229
 
        self.overrideEnv('BZR_PROGRESS_BAR', 'text')
 
259
        os.environ['BZR_PROGRESS_BAR'] = 'text'
230
260
        ui_factory = _mod_ui_text.TextUIFactory(None,
231
261
            test_progress._TTYStringIO(),
232
262
            test_progress._TTYStringIO())
313
343
            # however, it can still be forced on
314
344
            (FileStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),
315
345
            ):
316
 
            self.overrideEnv('TERM', term)
317
 
            self.overrideEnv('BZR_PROGRESS_BAR', pb)
 
346
            os.environ['TERM'] = term
 
347
            if pb is None:
 
348
                if 'BZR_PROGRESS_BAR' in os.environ:
 
349
                    del os.environ['BZR_PROGRESS_BAR']
 
350
            else:
 
351
                os.environ['BZR_PROGRESS_BAR'] = pb
318
352
            stdin = file_class('')
319
353
            stderr = file_class()
320
354
            stdout = file_class()
331
365
        stderr = test_progress._NonTTYStringIO()
332
366
        stdout = test_progress._NonTTYStringIO()
333
367
        for term_type in ['dumb', None, 'xterm']:
334
 
            self.overrideEnv('TERM', term_type)
 
368
            if term_type is None:
 
369
                del os.environ['TERM']
 
370
            else:
 
371
                os.environ['TERM'] = term_type
335
372
            uif = _mod_ui.make_ui_for_terminal(stdin, stdout, stderr)
336
373
            self.assertIsInstance(uif, _mod_ui_text.TextUIFactory,
337
374
                'TERM=%r' % (term_type,))
439
476
        self.assertIsNone('0', av)
440
477
        self.assertIsNone('on', av)
441
478
        self.assertIsNone('off', av)
442
 
 
443
 
 
444
 
class TestConfirmationUserInterfacePolicy(tests.TestCase):
445
 
 
446
 
    def test_confirm_action_default(self):
447
 
        base_ui = _mod_ui.NoninteractiveUIFactory()
448
 
        for answer in [True, False]:
449
 
            self.assertEquals(
450
 
                _mod_ui.ConfirmationUserInterfacePolicy(base_ui, answer, {})
451
 
                .confirm_action("Do something?",
452
 
                    "bzrlib.tests.do_something", {}),
453
 
                answer)
454
 
 
455
 
    def test_confirm_action_specific(self):
456
 
        base_ui = _mod_ui.NoninteractiveUIFactory()
457
 
        for default_answer in [True, False]:
458
 
            for specific_answer in [True, False]:
459
 
                for conf_id in ['given_id', 'other_id']:
460
 
                    wrapper = _mod_ui.ConfirmationUserInterfacePolicy(
461
 
                        base_ui, default_answer, dict(given_id=specific_answer))
462
 
                    result = wrapper.confirm_action("Do something?", conf_id, {})
463
 
                    if conf_id == 'given_id':
464
 
                        self.assertEquals(result, specific_answer)
465
 
                    else:
466
 
                        self.assertEquals(result, default_answer)
467
 
 
468
 
    def test_repr(self):
469
 
        base_ui = _mod_ui.NoninteractiveUIFactory()
470
 
        wrapper = _mod_ui.ConfirmationUserInterfacePolicy(
471
 
            base_ui, True, dict(a=2))
472
 
        self.assertThat(repr(wrapper),
473
 
            Equals("ConfirmationUserInterfacePolicy("
474
 
                "NoninteractiveUIFactory(), True, {'a': 2})"))
475
 
 
476
 
 
477
 
class TestProgressRecordingUI(tests.TestCase):
478
 
    """Test test-oriented UIFactory that records progress updates"""
479
 
 
480
 
    def test_nested_ignore_depth_beyond_one(self):
481
 
        # we only want to capture the first level out progress, not
482
 
        # want sub-components might do. So we have nested bars ignored.
483
 
        factory = ProgressRecordingUIFactory()
484
 
        pb1 = factory.nested_progress_bar()
485
 
        pb1.update('foo', 0, 1)
486
 
        pb2 = factory.nested_progress_bar()
487
 
        pb2.update('foo', 0, 1)
488
 
        pb2.finished()
489
 
        pb1.finished()
490
 
        self.assertEqual([("update", 0, 1, 'foo')], factory._calls)