← 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: 2011-05-11 11:35:28 UTC
  • mto: This revision was merged to the branch mainline in revision 5851.
  • Revision ID: john@arbash-meinel.com-20110511113528-qepibuwxicjrbb2h
Break compatibility with python <2.6.

This includes auditing the code for places where we were doing
explicit 'sys.version' checks and removing them as appropriate.

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('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:
144
152
    def test_text_factory_prompts_and_clears(self):
145
153
        # a get_boolean call should clear the pb before prompting
146
154
        out = test_progress._TTYStringIO()
147
 
        os.environ['TERM'] = 'xterm'
 
155
        self.overrideEnv('TERM', 'xterm')
148
156
        factory = _mod_ui_text.TextUIFactory(
149
157
            stdin=tests.StringIOWrapper("yada\ny\n"),
150
158
            stdout=out, stderr=out)
212
220
            pb.finished()
213
221
 
214
222
    def test_quietness(self):
215
 
        os.environ['BZR_PROGRESS_BAR'] = 'text'
 
223
        self.overrideEnv('BZR_PROGRESS_BAR', 'text')
216
224
        ui_factory = _mod_ui_text.TextUIFactory(None,
217
225
            test_progress._TTYStringIO(),
218
226
            test_progress._TTYStringIO())
224
232
 
225
233
    def test_text_ui_show_user_warning(self):
226
234
        from bzrlib.repofmt.groupcompress_repo import RepositoryFormat2a
227
 
        from bzrlib.repofmt.pack_repo import RepositoryFormatKnitPack5
 
235
        from bzrlib.repofmt.knitpack_repo import RepositoryFormatKnitPack5
228
236
        err = StringIO()
229
237
        out = StringIO()
230
238
        ui = tests.TextUIFactory(stdin=None, stdout=out, stderr=err)
299
307
            # however, it can still be forced on
300
308
            (FileStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),
301
309
            ):
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
 
310
            self.overrideEnv('TERM', term)
 
311
            self.overrideEnv('BZR_PROGRESS_BAR', pb)
308
312
            stdin = file_class('')
309
313
            stderr = file_class()
310
314
            stdout = file_class()
321
325
        stderr = test_progress._NonTTYStringIO()
322
326
        stdout = test_progress._NonTTYStringIO()
323
327
        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
 
328
            self.overrideEnv('TERM', term_type)
328
329
            uif = _mod_ui.make_ui_for_terminal(stdin, stdout, stderr)
329
330
            self.assertIsInstance(uif, _mod_ui_text.TextUIFactory,
330
331
                'TERM=%r' % (term_type,))
432
433
        self.assertIsNone('0', av)
433
434
        self.assertIsNone('on', av)
434
435
        self.assertIsNone('off', av)
 
436
 
 
437
 
 
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
class TestProgressRecordingUI(tests.TestCase):
 
472
    """Test test-oriented UIFactory that records progress updates"""
 
473
 
 
474
    def test_nested_ignore_depth_beyond_one(self):
 
475
        # we only want to capture the first level out progress, not
 
476
        # want sub-components might do. So we have nested bars ignored.
 
477
        factory = ProgressRecordingUIFactory()
 
478
        pb1 = factory.nested_progress_bar()
 
479
        pb1.update('foo', 0, 1)
 
480
        pb2 = factory.nested_progress_bar()
 
481
        pb2.update('foo', 0, 1)
 
482
        pb2.finished()
 
483
        pb1.finished()
 
484
        self.assertEqual([("update", 0, 1, 'foo')], factory._calls)