← 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 von Gagern
  • Date: 2010-05-02 18:16:37 UTC
  • mto: This revision was merged to the branch mainline in revision 5203.
  • Revision ID: martin.vgagern@gmx.net-20100502181637-wlkqn31xuybzt9gy
Add blackbox test for cat --directory.

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, 2008, 2009, 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
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
 
    config,
29
27
    errors,
30
28
    remote,
31
29
    repository,
35
33
from bzrlib.symbol_versioning import (
36
34
    deprecated_in,
37
35
    )
38
 
from bzrlib.tests import (
39
 
    fixtures,
40
 
    test_progress,
41
 
    )
 
36
from bzrlib.tests import test_progress
42
37
from bzrlib.ui import text as _mod_ui_text
43
 
from bzrlib.tests.testui import (
44
 
    ProgressRecordingUIFactory,
45
 
    )
46
 
 
47
 
 
48
 
class TestUIConfiguration(tests.TestCaseWithTransport):
49
 
 
50
 
    def test_output_encoding_configuration(self):
51
 
        enc = fixtures.generate_unicode_encodings().next()
52
 
        config.GlobalConfig().set_user_option('output_encoding',
53
 
            enc)
54
 
        ui = tests.TestUIFactory(stdin=None,
55
 
            stdout=tests.StringIOWrapper(),
56
 
            stderr=tests.StringIOWrapper())
57
 
        output = ui.make_output_stream()
58
 
        self.assertEquals(output.encoding, enc)
59
38
 
60
39
 
61
40
class TestTextUIFactory(tests.TestCase):
62
41
 
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
42
    def test_text_factory_ascii_password(self):
78
 
        ui = self.make_test_ui_factory('secret\n')
 
43
        ui = tests.TestUIFactory(stdin='secret\n',
 
44
                                 stdout=tests.StringIOWrapper(),
 
45
                                 stderr=tests.StringIOWrapper())
79
46
        pb = ui.nested_progress_bar()
80
47
        try:
81
48
            self.assertEqual('secret',
96
63
        We can't predict what encoding users will have for stdin, so we force
97
64
        it to utf8 to test that we transport the password correctly.
98
65
        """
99
 
        ui = self.make_test_ui_factory(u'baz\u1234'.encode('utf8'))
 
66
        ui = tests.TestUIFactory(stdin=u'baz\u1234'.encode('utf8'),
 
67
                                 stdout=tests.StringIOWrapper(),
 
68
                                 stderr=tests.StringIOWrapper())
100
69
        ui.stderr.encoding = ui.stdout.encoding = ui.stdin.encoding = 'utf8'
101
70
        pb = ui.nested_progress_bar()
102
71
        try:
114
83
        finally:
115
84
            pb.finished()
116
85
 
 
86
    def test_progress_note(self):
 
87
        stderr = tests.StringIOWrapper()
 
88
        stdout = tests.StringIOWrapper()
 
89
        ui_factory = _mod_ui_text.TextUIFactory(stdin=tests.StringIOWrapper(''),
 
90
                                                stderr=stderr,
 
91
                                                stdout=stdout)
 
92
        pb = ui_factory.nested_progress_bar()
 
93
        try:
 
94
            result = self.applyDeprecated(deprecated_in((2, 1, 0)),
 
95
                pb.note,
 
96
                't')
 
97
            self.assertEqual(None, result)
 
98
            self.assertEqual("t\n", stdout.getvalue())
 
99
            # Since there was no update() call, there should be no clear() call
 
100
            self.failIf(re.search(r'^\r {10,}\r$',
 
101
                                  stderr.getvalue()) is not None,
 
102
                        'We cleared the stderr without anything to put there')
 
103
        finally:
 
104
            pb.finished()
 
105
 
 
106
    def test_progress_note_clears(self):
 
107
        stderr = test_progress._TTYStringIO()
 
108
        stdout = test_progress._TTYStringIO()
 
109
        # so that we get a TextProgressBar
 
110
        os.environ['TERM'] = 'xterm'
 
111
        ui_factory = _mod_ui_text.TextUIFactory(
 
112
            stdin=tests.StringIOWrapper(''),
 
113
            stdout=stdout, stderr=stderr)
 
114
        self.assertIsInstance(ui_factory._progress_view,
 
115
                              _mod_ui_text.TextProgressView)
 
116
        pb = ui_factory.nested_progress_bar()
 
117
        try:
 
118
            # Create a progress update that isn't throttled
 
119
            pb.update('x', 1, 1)
 
120
            result = self.applyDeprecated(deprecated_in((2, 1, 0)),
 
121
                pb.note, 't')
 
122
            self.assertEqual(None, result)
 
123
            self.assertEqual("t\n", stdout.getvalue())
 
124
            # the exact contents will depend on the terminal width and we don't
 
125
            # care about that right now - but you're probably running it on at
 
126
            # least a 10-character wide terminal :)
 
127
            self.assertContainsRe(stderr.getvalue(), r'\r {10,}\r$')
 
128
        finally:
 
129
            pb.finished()
 
130
 
117
131
    def test_text_ui_get_boolean(self):
118
132
        stdin = tests.StringIOWrapper("y\n" # True
119
133
                                      "n\n" # False
162
176
        factory = _mod_ui_text.TextUIFactory(
163
177
            stdin=tests.StringIOWrapper("yada\ny\n"),
164
178
            stdout=out, stderr=out)
165
 
        factory._avail_width = lambda: 79
166
179
        pb = factory.nested_progress_bar()
167
180
        pb.show_bar = False
168
181
        pb.show_spinner = False
174
187
                                               factory.get_boolean,
175
188
                                               "what do you want"))
176
189
        output = out.getvalue()
177
 
        self.assertContainsRe(output,
178
 
            "| foo *\r\r  *\r*")
179
 
        self.assertContainsRe(output,
 
190
        self.assertContainsRe(factory.stdout.getvalue(),
 
191
            "foo *\r\r  *\r*")
 
192
        self.assertContainsRe(factory.stdout.getvalue(),
180
193
            r"what do you want\? \[y/n\]: what do you want\? \[y/n\]: ")
181
194
        # stdin should have been totally consumed
182
195
        self.assertEqual('', factory.stdin.readline())
372
385
 
373
386
    def test_test_ui_factory_progress(self):
374
387
        # there's no output; we just want to make sure this doesn't crash -
375
 
        # see https://bugs.launchpad.net/bzr/+bug/408201
 
388
        # see https://bugs.edge.launchpad.net/bzr/+bug/408201
376
389
        ui = tests.TestUIFactory()
377
390
        pb = ui.nested_progress_bar()
378
391
        pb.update('hello')
446
459
        self.assertIsNone('0', av)
447
460
        self.assertIsNone('on', av)
448
461
        self.assertIsNone('off', av)
449
 
 
450
 
 
451
 
class TestConfirmationUserInterfacePolicy(tests.TestCase):
452
 
 
453
 
    def test_confirm_action_default(self):
454
 
        base_ui = _mod_ui.NoninteractiveUIFactory()
455
 
        for answer in [True, False]:
456
 
            self.assertEquals(
457
 
                _mod_ui.ConfirmationUserInterfacePolicy(base_ui, answer, {})
458
 
                .confirm_action("Do something?",
459
 
                    "bzrlib.tests.do_something", {}),
460
 
                answer)
461
 
 
462
 
    def test_confirm_action_specific(self):
463
 
        base_ui = _mod_ui.NoninteractiveUIFactory()
464
 
        for default_answer in [True, False]:
465
 
            for specific_answer in [True, False]:
466
 
                for conf_id in ['given_id', 'other_id']:
467
 
                    wrapper = _mod_ui.ConfirmationUserInterfacePolicy(
468
 
                        base_ui, default_answer, dict(given_id=specific_answer))
469
 
                    result = wrapper.confirm_action("Do something?", conf_id, {})
470
 
                    if conf_id == 'given_id':
471
 
                        self.assertEquals(result, specific_answer)
472
 
                    else:
473
 
                        self.assertEquals(result, default_answer)
474
 
 
475
 
    def test_repr(self):
476
 
        base_ui = _mod_ui.NoninteractiveUIFactory()
477
 
        wrapper = _mod_ui.ConfirmationUserInterfacePolicy(
478
 
            base_ui, True, dict(a=2))
479
 
        self.assertThat(repr(wrapper),
480
 
            Equals("ConfirmationUserInterfacePolicy("
481
 
                "NoninteractiveUIFactory(), True, {'a': 2})"))
482
 
 
483
 
 
484
 
class TestProgressRecordingUI(tests.TestCase):
485
 
    """Test test-oriented UIFactory that records progress updates"""
486
 
 
487
 
    def test_nested_ignore_depth_beyond_one(self):
488
 
        # we only want to capture the first level out progress, not
489
 
        # want sub-components might do. So we have nested bars ignored.
490
 
        factory = ProgressRecordingUIFactory()
491
 
        pb1 = factory.nested_progress_bar()
492
 
        pb1.update('foo', 0, 1)
493
 
        pb2 = factory.nested_progress_bar()
494
 
        pb2.update('foo', 0, 1)
495
 
        pb2.finished()
496
 
        pb1.finished()
497
 
        self.assertEqual([("update", 0, 1, 'foo')], factory._calls)