← Back to branch summary

~mhammond/bzr/update-r

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_ui.py

  • Committer: Mark Hammond
  • Date: 2008-08-19 01:09:37 UTC
  • mfrom: (2009.1.1629 +trunk)
  • Revision ID: mhammond@skippinet.com.au-20080819010937-aohklatall0s6m3z
First attempt to merge .dev and resolve the conflicts (but tests are 
failing)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_ui.py
1
 
# Copyright (C) 2005 by Canonical Ltd
 
1
# Copyright (C) 2005 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
24
24
 
25
25
import bzrlib
26
26
import bzrlib.errors as errors
27
 
from bzrlib.progress import TTYProgressBar, ProgressBarStack
28
 
from bzrlib.tests import TestCase
 
27
from bzrlib.progress import (
 
28
    DotsProgressBar,
 
29
    ProgressBarStack,
 
30
    TTYProgressBar,
 
31
    )
 
32
from bzrlib.tests import (
 
33
    TestCase,
 
34
    TestUIFactory,
 
35
    StringIOWrapper,
 
36
    )
29
37
from bzrlib.tests.test_progress import _TTYStringIO
30
 
from bzrlib.ui import SilentUIFactory
 
38
from bzrlib.ui import (
 
39
    CLIUIFactory,
 
40
    SilentUIFactory,
 
41
    )
31
42
from bzrlib.ui.text import TextUIFactory
32
43
 
33
44
 
35
46
 
36
47
    def test_silent_factory(self):
37
48
        ui = SilentUIFactory()
38
 
        pb = ui.nested_progress_bar()
39
 
        try:
40
 
            # TODO: Test that there is no output from SilentUIFactory
41
 
    
42
 
            self.assertEquals(ui.get_password(), None)
43
 
            self.assertEquals(ui.get_password(u'Hello There \u1234 %(user)s',
44
 
                                              user=u'some\u1234')
45
 
                             , None)
46
 
        finally:
47
 
            pb.finished()
48
 
 
49
 
    def test_text_factory(self):
50
 
        ui = TextUIFactory()
51
 
        pb = ui.nested_progress_bar()
52
 
        pb.finished()
53
 
        # TODO: Test the output from TextUIFactory, perhaps by overriding sys.stdout
54
 
 
55
 
        # Unfortunately we can't actually test the ui.get_password() because 
56
 
        # that would actually prompt the user for a password during the test suite
57
 
        # This has been tested manually with both LANG=en_US.utf-8 and LANG=C
58
 
        # print
59
 
        # self.assertEquals(ui.get_password(u"%(user)s please type 'bogus'",
60
 
        #                                   user=u'some\u1234')
61
 
        #                  , 'bogus')
62
 
 
 
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()
63
100
 
64
101
    def test_progress_note(self):
65
102
        stderr = StringIO()
73
110
            self.assertEqual(None, result)
74
111
            self.assertEqual("t\n", stdout.getvalue())
75
112
            # Since there was no update() call, there should be no clear() call
76
 
            self.failIf(re.search(r'^\r {10,}\r$', stderr.getvalue()) is not None,
 
113
            self.failIf(re.search(r'^\r {10,}\r$',
 
114
                                  stderr.getvalue()) is not None,
77
115
                        'We cleared the stderr without anything to put there')
78
116
        finally:
79
117
            pb.finished()
135
173
 
136
174
    def test_text_factory_setting_progress_bar(self):
137
175
        # we should be able to choose the progress bar type used.
138
 
        factory = bzrlib.ui.text.TextUIFactory(
139
 
            bar_type=bzrlib.progress.DotsProgressBar)
 
176
        factory = TextUIFactory(bar_type=DotsProgressBar)
140
177
        bar = factory.nested_progress_bar()
141
178
        bar.finished()
142
 
        self.assertIsInstance(bar, bzrlib.progress.DotsProgressBar)
 
179
        self.assertIsInstance(bar, DotsProgressBar)
143
180
 
144
181
    def test_cli_stdin_is_default_stdin(self):
145
 
        factory = bzrlib.ui.CLIUIFactory()
 
182
        factory = CLIUIFactory()
146
183
        self.assertEqual(sys.stdin, factory.stdin)
147
184
 
148
185
    def assert_get_bool_acceptance_of_user_input(self, factory):
149
 
        factory.stdin = StringIO("y\nyes with garbage\nyes\nn\nnot an answer\nno\nfoo\n")
 
186
        factory.stdin = StringIO("y\nyes with garbage\n"
 
187
                                 "yes\nn\nnot an answer\n"
 
188
                                 "no\nfoo\n")
150
189
        factory.stdout = StringIO()
151
190
        # there is no output from the base factory
152
191
        self.assertEqual(True, factory.get_boolean(""))
154
193
        self.assertEqual(False, factory.get_boolean(""))
155
194
        self.assertEqual(False, factory.get_boolean(""))
156
195
        self.assertEqual("foo\n", factory.stdin.read())
 
196
        # stdin should be empty
 
197
        self.assertEqual('', factory.stdin.readline())
157
198
 
158
199
    def test_silent_ui_getbool(self):
159
 
        factory = bzrlib.ui.SilentUIFactory()
 
200
        factory = SilentUIFactory()
160
201
        self.assert_get_bool_acceptance_of_user_input(factory)
161
202
 
162
203
    def test_silent_factory_prompts_silently(self):
163
 
        factory = bzrlib.ui.SilentUIFactory()
 
204
        factory = SilentUIFactory()
164
205
        stdout = StringIO()
165
206
        factory.stdin = StringIO("y\n")
166
 
        self.assertEqual(
167
 
            True,
168
 
            self.apply_redirected(
169
 
                None, stdout, stdout, factory.get_boolean, "foo")
170
 
            )
 
207
        self.assertEqual(True,
 
208
                         self.apply_redirected(None, stdout, stdout,
 
209
                                               factory.get_boolean, "foo"))
171
210
        self.assertEqual("", stdout.getvalue())
172
 
        
 
211
        # stdin should be empty
 
212
        self.assertEqual('', factory.stdin.readline())
 
213
 
173
214
    def test_text_ui_getbool(self):
174
 
        factory = bzrlib.ui.text.TextUIFactory()
 
215
        factory = TextUIFactory()
175
216
        self.assert_get_bool_acceptance_of_user_input(factory)
176
217
 
177
218
    def test_text_factory_prompts_and_clears(self):
178
219
        # a get_boolean call should clear the pb before prompting
179
 
        factory = bzrlib.ui.text.TextUIFactory()
 
220
        factory = TextUIFactory(bar_type=DotsProgressBar)
180
221
        factory.stdout = _TTYStringIO()
181
222
        factory.stdin = StringIO("yada\ny\n")
182
 
        pb = self.apply_redirected(
183
 
            factory.stdin, factory.stdout, factory.stdout, factory.nested_progress_bar)
 
223
        pb = self.apply_redirected(factory.stdin, factory.stdout,
 
224
                                   factory.stdout, factory.nested_progress_bar)
184
225
        pb.start_time = None
185
 
        self.apply_redirected(
186
 
            factory.stdin, factory.stdout, factory.stdout, pb.update, "foo", 0, 1)
187
 
        self.assertEqual(
188
 
            True,
189
 
            self.apply_redirected(
190
 
                None, factory.stdout, factory.stdout, factory.get_boolean, "what do you want")
191
 
            )
192
 
        # use a regular expression so that we don't depend on the particular
193
 
        # screen width - could also set and restore $COLUMN if that has
194
 
        # priority on all platforms, but it doesn't at present.
 
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"))
195
233
        output = factory.stdout.getvalue()
196
 
        if not re.match(
197
 
            "\r/ \\[    *\\] foo 0/1"
198
 
            "\r   *" 
199
 
            "\rwhat do you want\\? \\[y/n\\]:what do you want\\? \\[y/n\\]:", 
200
 
            output):
201
 
            self.fail("didn't match factory output %r, %s" % (factory, output))
 
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