← 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: Martin Pool
  • Date: 2011-03-28 01:28:09 UTC
  • mto: (5425.4.19 220464-stale-locks)
  • mto: This revision was merged to the branch mainline in revision 5970.
  • Revision ID: mbp@canonical.com-20110328012809-frw003r09tcrxkiz
Represent lock held info as an object, not just a dict

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_ui.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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
20
22
import time
21
23
 
22
24
from StringIO import StringIO
23
25
 
24
 
from testtools.matchers import *
25
 
 
26
26
from bzrlib import (
27
27
    config,
 
28
    errors,
28
29
    remote,
 
30
    repository,
29
31
    tests,
30
32
    ui as _mod_ui,
31
33
    )
 
34
from bzrlib.symbol_versioning import (
 
35
    deprecated_in,
 
36
    )
32
37
from bzrlib.tests import (
33
38
    fixtures,
34
39
    test_progress,
48
53
        ui = tests.TestUIFactory(stdin=None,
49
54
            stdout=tests.StringIOWrapper(),
50
55
            stderr=tests.StringIOWrapper())
51
 
        output = ui.make_output_stream()
52
 
        self.assertEquals(output.encoding, enc)
 
56
        os = ui.make_output_stream()
 
57
        self.assertEquals(os.encoding, enc)
53
58
 
54
59
 
55
60
class TestTextUIFactory(tests.TestCase):
56
61
 
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('Should %(thing)s pass?',
67
 
            'bzrlib.tests.test_ui.confirmation',
68
 
            {'thing': 'this'},),
69
 
            False)
70
 
 
71
62
    def test_text_factory_ascii_password(self):
72
 
        ui = self.make_test_ui_factory('secret\n')
 
63
        ui = tests.TestUIFactory(stdin='secret\n',
 
64
                                 stdout=tests.StringIOWrapper(),
 
65
                                 stderr=tests.StringIOWrapper())
73
66
        pb = ui.nested_progress_bar()
74
67
        try:
75
68
            self.assertEqual('secret',
90
83
        We can't predict what encoding users will have for stdin, so we force
91
84
        it to utf8 to test that we transport the password correctly.
92
85
        """
93
 
        ui = self.make_test_ui_factory(u'baz\u1234'.encode('utf8'))
 
86
        ui = tests.TestUIFactory(stdin=u'baz\u1234'.encode('utf8'),
 
87
                                 stdout=tests.StringIOWrapper(),
 
88
                                 stderr=tests.StringIOWrapper())
94
89
        ui.stderr.encoding = ui.stdout.encoding = ui.stdin.encoding = 'utf8'
95
90
        pb = ui.nested_progress_bar()
96
91
        try:
152
147
    def test_text_factory_prompts_and_clears(self):
153
148
        # a get_boolean call should clear the pb before prompting
154
149
        out = test_progress._TTYStringIO()
155
 
        self.overrideEnv('TERM', 'xterm')
 
150
        os.environ['TERM'] = 'xterm'
156
151
        factory = _mod_ui_text.TextUIFactory(
157
152
            stdin=tests.StringIOWrapper("yada\ny\n"),
158
153
            stdout=out, stderr=out)
220
215
            pb.finished()
221
216
 
222
217
    def test_quietness(self):
223
 
        self.overrideEnv('BZR_PROGRESS_BAR', 'text')
 
218
        os.environ['BZR_PROGRESS_BAR'] = 'text'
224
219
        ui_factory = _mod_ui_text.TextUIFactory(None,
225
220
            test_progress._TTYStringIO(),
226
221
            test_progress._TTYStringIO())
232
227
 
233
228
    def test_text_ui_show_user_warning(self):
234
229
        from bzrlib.repofmt.groupcompress_repo import RepositoryFormat2a
235
 
        from bzrlib.repofmt.knitpack_repo import RepositoryFormatKnitPack5
 
230
        from bzrlib.repofmt.pack_repo import RepositoryFormatKnitPack5
236
231
        err = StringIO()
237
232
        out = StringIO()
238
233
        ui = tests.TextUIFactory(stdin=None, stdout=out, stderr=err)
307
302
            # however, it can still be forced on
308
303
            (FileStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),
309
304
            ):
310
 
            self.overrideEnv('TERM', term)
311
 
            self.overrideEnv('BZR_PROGRESS_BAR', pb)
 
305
            os.environ['TERM'] = term
 
306
            if pb is None:
 
307
                if 'BZR_PROGRESS_BAR' in os.environ:
 
308
                    del os.environ['BZR_PROGRESS_BAR']
 
309
            else:
 
310
                os.environ['BZR_PROGRESS_BAR'] = pb
312
311
            stdin = file_class('')
313
312
            stderr = file_class()
314
313
            stdout = file_class()
325
324
        stderr = test_progress._NonTTYStringIO()
326
325
        stdout = test_progress._NonTTYStringIO()
327
326
        for term_type in ['dumb', None, 'xterm']:
328
 
            self.overrideEnv('TERM', term_type)
 
327
            if term_type is None:
 
328
                del os.environ['TERM']
 
329
            else:
 
330
                os.environ['TERM'] = term_type
329
331
            uif = _mod_ui.make_ui_for_terminal(stdin, stdout, stderr)
330
332
            self.assertIsInstance(uif, _mod_ui_text.TextUIFactory,
331
333
                'TERM=%r' % (term_type,))
435
437
        self.assertIsNone('off', av)
436
438
 
437
439
 
438
 
class TestConfirmationUserInterfacePolicy(tests.TestCase):
439
 
 
440
 
    def test_confirm_action_default(self):
441
 
        base_ui = _mod_ui.NoninteractiveUIFactory()
442
 
        for answer in [True, False]:
443
 
            self.assertEquals(
444
 
                _mod_ui.ConfirmationUserInterfacePolicy(base_ui, answer, {})
445
 
                .confirm_action("Do something?",
446
 
                    "bzrlib.tests.do_something", {}),
447
 
                answer)
448
 
 
449
 
    def test_confirm_action_specific(self):
450
 
        base_ui = _mod_ui.NoninteractiveUIFactory()
451
 
        for default_answer in [True, False]:
452
 
            for specific_answer in [True, False]:
453
 
                for conf_id in ['given_id', 'other_id']:
454
 
                    wrapper = _mod_ui.ConfirmationUserInterfacePolicy(
455
 
                        base_ui, default_answer, dict(given_id=specific_answer))
456
 
                    result = wrapper.confirm_action("Do something?", conf_id, {})
457
 
                    if conf_id == 'given_id':
458
 
                        self.assertEquals(result, specific_answer)
459
 
                    else:
460
 
                        self.assertEquals(result, default_answer)
461
 
 
462
 
    def test_repr(self):
463
 
        base_ui = _mod_ui.NoninteractiveUIFactory()
464
 
        wrapper = _mod_ui.ConfirmationUserInterfacePolicy(
465
 
            base_ui, True, dict(a=2))
466
 
        self.assertThat(repr(wrapper),
467
 
            Equals("ConfirmationUserInterfacePolicy("
468
 
                "NoninteractiveUIFactory(), True, {'a': 2})"))
469
 
 
470
 
 
471
440
class TestProgressRecordingUI(tests.TestCase):
472
441
    """Test test-oriented UIFactory that records progress updates"""
473
442