← 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: Canonical.com Patch Queue Manager
  • Date: 2008-04-07 07:52:50 UTC
  • mfrom: (3340.1.1 208418-1.4)
  • Revision ID: pqm@pqm.ubuntu.com-20080407075250-phs53xnslo8boaeo
Return the correct knit serialisation method in _StreamAccess.
        (Andrew Bennetts, Martin Pool, Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_ui.py
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
"""Tests for the bzrlib ui
 
18
"""
 
19
 
 
20
import os
 
21
from StringIO import StringIO
 
22
import re
 
23
import sys
 
24
 
 
25
import bzrlib
 
26
import bzrlib.errors as errors
 
27
from bzrlib.progress import (
 
28
    DotsProgressBar,
 
29
    ProgressBarStack,
 
30
    TTYProgressBar,
 
31
    )
 
32
from bzrlib.tests import (
 
33
    TestCase,
 
34
    TestUIFactory,
 
35
    StringIOWrapper,
 
36
    )
 
37
from bzrlib.tests.test_progress import _TTYStringIO
 
38
from bzrlib.ui import (
 
39
    CLIUIFactory,
 
40
    SilentUIFactory,
 
41
    )
 
42
from bzrlib.ui.text import TextUIFactory
 
43
 
 
44
 
 
45
class UITests(TestCase):
 
46
 
 
47
    def test_silent_factory(self):
 
48
        ui = SilentUIFactory()
 
49
        stdout = StringIO()
 
50
        self.assertEqual(None,
 
51
                         self.apply_redirected(None, stdout, stdout,
 
52
                                               ui.get_password))
 
53
        self.assertEqual('', stdout.getvalue())
 
54
        self.assertEqual(None,
 
55
                         self.apply_redirected(None, stdout, stdout,
 
56
                                               ui.get_password,
 
57
                                               u'Hello\u1234 %(user)s',
 
58
                                               user=u'some\u1234'))
 
59
        self.assertEqual('', stdout.getvalue())
 
60
 
 
61
    def test_text_factory_ascii_password(self):
 
62
        ui = TestUIFactory(stdin='secret\n', stdout=StringIOWrapper())
 
63
        pb = ui.nested_progress_bar()
 
64
        try:
 
65
            self.assertEqual('secret',
 
66
                             self.apply_redirected(ui.stdin, ui.stdout,
 
67
                                                   ui.stdout,
 
68
                                                   ui.get_password))
 
69
            # ': ' is appended to prompt
 
70
            self.assertEqual(': ', ui.stdout.getvalue())
 
71
            # stdin should be empty
 
72
            self.assertEqual('', ui.stdin.readline())
 
73
        finally:
 
74
            pb.finished()
 
75
 
 
76
    def test_text_factory_utf8_password(self):
 
77
        """Test an utf8 password.
 
78
 
 
79
        We can't predict what encoding users will have for stdin, so we force
 
80
        it to utf8 to test that we transport the password correctly.
 
81
        """
 
82
        ui = TestUIFactory(stdin=u'baz\u1234'.encode('utf8'),
 
83
                           stdout=StringIOWrapper())
 
84
        ui.stdin.encoding = 'utf8'
 
85
        ui.stdout.encoding = ui.stdin.encoding
 
86
        pb = ui.nested_progress_bar()
 
87
        try:
 
88
            password = self.apply_redirected(ui.stdin, ui.stdout, ui.stdout,
 
89
                                             ui.get_password,
 
90
                                             u'Hello \u1234 %(user)s',
 
91
                                             user=u'some\u1234')
 
92
            # We use StringIO objects, we need to decode them
 
93
            self.assertEqual(u'baz\u1234', password.decode('utf8'))
 
94
            self.assertEqual(u'Hello \u1234 some\u1234: ',
 
95
                             ui.stdout.getvalue().decode('utf8'))
 
96
            # stdin should be empty
 
97
            self.assertEqual('', ui.stdin.readline())
 
98
        finally:
 
99
            pb.finished()
 
100
 
 
101
    def test_progress_note(self):
 
102
        stderr = StringIO()
 
103
        stdout = StringIO()
 
104
        ui_factory = TextUIFactory(bar_type=TTYProgressBar)
 
105
        pb = ui_factory.nested_progress_bar()
 
106
        try:
 
107
            pb.to_messages_file = stdout
 
108
            ui_factory._progress_bar_stack.bottom().to_file = stderr
 
109
            result = pb.note('t')
 
110
            self.assertEqual(None, result)
 
111
            self.assertEqual("t\n", stdout.getvalue())
 
112
            # Since there was no update() call, there should be no clear() call
 
113
            self.failIf(re.search(r'^\r {10,}\r$',
 
114
                                  stderr.getvalue()) is not None,
 
115
                        'We cleared the stderr without anything to put there')
 
116
        finally:
 
117
            pb.finished()
 
118
 
 
119
    def test_progress_note_clears(self):
 
120
        stderr = StringIO()
 
121
        stdout = StringIO()
 
122
        # The PQM redirects the output to a file, so it
 
123
        # defaults to creating a Dots progress bar. we
 
124
        # need to force it to believe we are a TTY
 
125
        ui_factory = TextUIFactory(bar_type=TTYProgressBar)
 
126
        pb = ui_factory.nested_progress_bar()
 
127
        try:
 
128
            pb.to_messages_file = stdout
 
129
            ui_factory._progress_bar_stack.bottom().to_file = stderr
 
130
            # Create a progress update that isn't throttled
 
131
            pb.start_time -= 10
 
132
            pb.update('x', 1, 1)
 
133
            result = pb.note('t')
 
134
            self.assertEqual(None, result)
 
135
            self.assertEqual("t\n", stdout.getvalue())
 
136
            # the exact contents will depend on the terminal width and we don't
 
137
            # care about that right now - but you're probably running it on at
 
138
            # least a 10-character wide terminal :)
 
139
            self.assertContainsRe(stderr.getvalue(), r'\r {10,}\r$')
 
140
        finally:
 
141
            pb.finished()
 
142
 
 
143
    def test_progress_nested(self):
 
144
        # test factory based nested and popping.
 
145
        ui = TextUIFactory()
 
146
        pb1 = ui.nested_progress_bar()
 
147
        pb2 = ui.nested_progress_bar()
 
148
        self.assertRaises(errors.MissingProgressBarFinish, pb1.finished)
 
149
        pb2.finished()
 
150
        pb1.finished()
 
151
 
 
152
    def test_progress_stack(self):
 
153
        # test the progress bar stack which the default text factory 
 
154
        # uses.
 
155
        stderr = StringIO()
 
156
        stdout = StringIO()
 
157
        # make a stack, which accepts parameters like a pb.
 
158
        stack = ProgressBarStack(to_file=stderr, to_messages_file=stdout)
 
159
        # but is not one
 
160
        self.assertFalse(getattr(stack, 'note', False))
 
161
        pb1 = stack.get_nested()
 
162
        pb2 = stack.get_nested()
 
163
        self.assertRaises(errors.MissingProgressBarFinish, pb1.finished)
 
164
        pb2.finished()
 
165
        pb1.finished()
 
166
        # the text ui factory never actually removes the stack once its setup.
 
167
        # we need to be able to nest again correctly from here.
 
168
        pb1 = stack.get_nested()
 
169
        pb2 = stack.get_nested()
 
170
        self.assertRaises(errors.MissingProgressBarFinish, pb1.finished)
 
171
        pb2.finished()
 
172
        pb1.finished()
 
173
 
 
174
    def test_text_factory_setting_progress_bar(self):
 
175
        # we should be able to choose the progress bar type used.
 
176
        factory = TextUIFactory(bar_type=DotsProgressBar)
 
177
        bar = factory.nested_progress_bar()
 
178
        bar.finished()
 
179
        self.assertIsInstance(bar, DotsProgressBar)
 
180
 
 
181
    def test_cli_stdin_is_default_stdin(self):
 
182
        factory = CLIUIFactory()
 
183
        self.assertEqual(sys.stdin, factory.stdin)
 
184
 
 
185
    def assert_get_bool_acceptance_of_user_input(self, factory):
 
186
        factory.stdin = StringIO("y\nyes with garbage\n"
 
187
                                 "yes\nn\nnot an answer\n"
 
188
                                 "no\nfoo\n")
 
189
        factory.stdout = StringIO()
 
190
        # there is no output from the base factory
 
191
        self.assertEqual(True, factory.get_boolean(""))
 
192
        self.assertEqual(True, factory.get_boolean(""))
 
193
        self.assertEqual(False, factory.get_boolean(""))
 
194
        self.assertEqual(False, factory.get_boolean(""))
 
195
        self.assertEqual("foo\n", factory.stdin.read())
 
196
        # stdin should be empty
 
197
        self.assertEqual('', factory.stdin.readline())
 
198
 
 
199
    def test_silent_ui_getbool(self):
 
200
        factory = SilentUIFactory()
 
201
        self.assert_get_bool_acceptance_of_user_input(factory)
 
202
 
 
203
    def test_silent_factory_prompts_silently(self):
 
204
        factory = SilentUIFactory()
 
205
        stdout = StringIO()
 
206
        factory.stdin = StringIO("y\n")
 
207
        self.assertEqual(True,
 
208
                         self.apply_redirected(None, stdout, stdout,
 
209
                                               factory.get_boolean, "foo"))
 
210
        self.assertEqual("", stdout.getvalue())
 
211
        # stdin should be empty
 
212
        self.assertEqual('', factory.stdin.readline())
 
213
 
 
214
    def test_text_ui_getbool(self):
 
215
        factory = TextUIFactory()
 
216
        self.assert_get_bool_acceptance_of_user_input(factory)
 
217
 
 
218
    def test_text_factory_prompts_and_clears(self):
 
219
        # a get_boolean call should clear the pb before prompting
 
220
        factory = TextUIFactory(bar_type=DotsProgressBar)
 
221
        factory.stdout = _TTYStringIO()
 
222
        factory.stdin = StringIO("yada\ny\n")
 
223
        pb = self.apply_redirected(factory.stdin, factory.stdout,
 
224
                                   factory.stdout, factory.nested_progress_bar)
 
225
        pb.start_time = None
 
226
        self.apply_redirected(factory.stdin, factory.stdout,
 
227
                              factory.stdout, pb.update, "foo", 0, 1)
 
228
        self.assertEqual(True,
 
229
                         self.apply_redirected(None, factory.stdout,
 
230
                                               factory.stdout,
 
231
                                               factory.get_boolean,
 
232
                                               "what do you want"))
 
233
        output = factory.stdout.getvalue()
 
234
        self.assertEqual("foo: .\n"
 
235
                         "what do you want? [y/n]: what do you want? [y/n]: ",
 
236
                         factory.stdout.getvalue())
 
237
        # stdin should be empty
 
238
        self.assertEqual('', factory.stdin.readline())
 
239