← 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: 2009-07-24 03:15:56 UTC
  • mfrom: (4565 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4566.
  • Revision ID: mbp@sourcefrog.net-20090724031556-5zyef6f1ixtn6r3z
merge news

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_ui.py
31
31
from bzrlib.symbol_versioning import (
32
32
    deprecated_in,
33
33
    )
34
 
from bzrlib.tests.test_progress import _TTYStringIO
 
34
from bzrlib.tests import (
 
35
    TestCase,
 
36
    TestUIFactory,
 
37
    StringIOWrapper,
 
38
    )
 
39
from bzrlib.tests.test_progress import (
 
40
    _NonTTYStringIO,
 
41
    _TTYStringIO,
 
42
    )
 
43
from bzrlib.ui import (
 
44
    CannedInputUIFactory,
 
45
    CLIUIFactory,
 
46
    SilentUIFactory,
 
47
    UIFactory,
 
48
    make_ui_for_terminal,
 
49
    )
35
50
from bzrlib.ui.text import (
36
51
    NullProgressView,
37
52
    TextProgressView,
41
56
 
42
57
class UITests(tests.TestCase):
43
58
 
44
 
    def test_silent_factory(self):
45
 
        ui = _mod_ui.SilentUIFactory()
46
 
        stdout = StringIO()
47
 
        self.assertEqual(None,
48
 
                         self.apply_redirected(None, stdout, stdout,
49
 
                                               ui.get_password))
50
 
        self.assertEqual('', stdout.getvalue())
51
 
        self.assertEqual(None,
52
 
                         self.apply_redirected(None, stdout, stdout,
53
 
                                               ui.get_password,
54
 
                                               u'Hello\u1234 %(user)s',
55
 
                                               user=u'some\u1234'))
56
 
        self.assertEqual('', stdout.getvalue())
57
 
 
58
59
    def test_text_factory_ascii_password(self):
59
60
        ui = tests.TestUIFactory(stdin='secret\n',
60
61
                                 stdout=tests.StringIOWrapper(),
102
103
    def test_progress_construction(self):
103
104
        """TextUIFactory constructs the right progress view.
104
105
        """
105
 
        os.environ['BZR_PROGRESS_BAR'] = 'none'
106
 
        self.assertIsInstance(TextUIFactory()._progress_view,
107
 
            NullProgressView)
108
 
 
109
 
        os.environ['BZR_PROGRESS_BAR'] = 'text'
110
 
        self.assertIsInstance(TextUIFactory()._progress_view,
111
 
            TextProgressView)
112
 
 
113
 
        os.environ['BZR_PROGRESS_BAR'] = 'text'
114
 
        self.assertIsInstance(TextUIFactory()._progress_view,
115
 
            TextProgressView)
116
 
 
117
 
        del os.environ['BZR_PROGRESS_BAR']
118
 
        self.assertIsInstance(TextUIFactory()._progress_view,
119
 
            TextProgressView)
 
106
        for (file_class, term, pb, expected_pb_class) in (
 
107
            # on an xterm, either use them or not as the user requests,
 
108
            # otherwise default on
 
109
            (_TTYStringIO, 'xterm', 'none', NullProgressView),
 
110
            (_TTYStringIO, 'xterm', 'text', TextProgressView),
 
111
            (_TTYStringIO, 'xterm', None, TextProgressView),
 
112
            # on a dumb terminal, again if there's explicit configuration do
 
113
            # it, otherwise default off
 
114
            (_TTYStringIO, 'dumb', 'none', NullProgressView),
 
115
            (_TTYStringIO, 'dumb', 'text', TextProgressView),
 
116
            (_TTYStringIO, 'dumb', None, NullProgressView),
 
117
            # on a non-tty terminal, it's null regardless of $TERM
 
118
            (StringIO, 'xterm', None, NullProgressView),
 
119
            (StringIO, 'dumb', None, NullProgressView),
 
120
            # however, it can still be forced on
 
121
            (StringIO, 'dumb', 'text', TextProgressView),
 
122
            ):
 
123
            os.environ['TERM'] = term
 
124
            if pb is None:
 
125
                if 'BZR_PROGRESS_BAR' in os.environ:
 
126
                    del os.environ['BZR_PROGRESS_BAR']
 
127
            else:
 
128
                os.environ['BZR_PROGRESS_BAR'] = pb
 
129
            stdin = file_class('')
 
130
            stderr = file_class()
 
131
            stdout = file_class()
 
132
            uif = make_ui_for_terminal(stdin, stdout, stderr)
 
133
            self.assertIsInstance(uif, TextUIFactory,
 
134
                "TERM=%s BZR_PROGRESS_BAR=%s uif=%r" % (term, pb, uif,))
 
135
            self.assertIsInstance(uif.make_progress_view(),
 
136
                expected_pb_class,
 
137
                "TERM=%s BZR_PROGRESS_BAR=%s uif=%r" % (term, pb, uif,))
 
138
 
 
139
    def test_text_ui_non_terminal(self):
 
140
        """Even on non-ttys, make_ui_for_terminal gives a text ui."""
 
141
        stdin = _NonTTYStringIO('')
 
142
        stderr = _NonTTYStringIO()
 
143
        stdout = _NonTTYStringIO()
 
144
        for term_type in ['dumb', None, 'xterm']:
 
145
            if term_type is None:
 
146
                del os.environ['TERM']
 
147
            else:
 
148
                os.environ['TERM'] = term_type
 
149
            uif = make_ui_for_terminal(stdin, stdout, stderr)
 
150
            self.assertIsInstance(uif, TextUIFactory,
 
151
                'TERM=%r' % (term_type,))
120
152
 
121
153
    def test_progress_note(self):
122
154
        stderr = StringIO()
137
169
            pb.finished()
138
170
 
139
171
    def test_progress_note_clears(self):
140
 
        stderr = StringIO()
141
 
        stdout = StringIO()
142
 
        # The PQM redirects the output to a file, so it
143
 
        # defaults to creating a Dots progress bar. we
144
 
        # need to force it to believe we are a TTY
 
172
        stderr = _TTYStringIO()
 
173
        stdout = _TTYStringIO()
 
174
        # so that we get a TextProgressBar
 
175
        os.environ['TERM'] = 'xterm'
145
176
        ui_factory = TextUIFactory(
146
177
            stdin=StringIO(''),
147
178
            stdout=stdout, stderr=stderr)
 
179
        self.assertIsInstance(ui_factory._progress_view,
 
180
            TextProgressView)
148
181
        pb = ui_factory.nested_progress_bar()
149
182
        try:
150
183
            # Create a progress update that isn't throttled
173
206
        pb2.finished()
174
207
        pb1.finished()
175
208
 
176
 
    def assert_get_bool_acceptance_of_user_input(self, factory):
177
 
        factory.stdin = StringIO("y\nyes with garbage\n"
178
 
                                 "yes\nn\nnot an answer\n"
179
 
                                 "no\n"
180
 
                                 "N\nY\n"
181
 
                                 "foo\n"
182
 
                                )
183
 
        factory.stdout = StringIO()
184
 
        factory.stderr = StringIO()
185
 
        # there is no output from the base factory
186
 
        self.assertEqual(True, factory.get_boolean(""))
187
 
        self.assertEqual(True, factory.get_boolean(""))
188
 
        self.assertEqual(False, factory.get_boolean(""))
189
 
        self.assertEqual(False, factory.get_boolean(""))
190
 
        self.assertEqual(False, factory.get_boolean(""))
191
 
        self.assertEqual(True, factory.get_boolean(""))
 
209
    def test_text_ui_get_boolean(self):
 
210
        stdin = StringIO("y\n" # True
 
211
                         "n\n" # False
 
212
                         "yes with garbage\nY\n" # True
 
213
                         "not an answer\nno\n" # False
 
214
                         "I'm sure!\nyes\n" # True
 
215
                         "NO\n" # False
 
216
                         "foo\n")
 
217
        stdout = StringIO()
 
218
        stderr = StringIO()
 
219
        factory = TextUIFactory(stdin, stdout, stderr)
 
220
        self.assertEqual(True, factory.get_boolean(""))
 
221
        self.assertEqual(False, factory.get_boolean(""))
 
222
        self.assertEqual(True, factory.get_boolean(""))
 
223
        self.assertEqual(False, factory.get_boolean(""))
 
224
        self.assertEqual(True, factory.get_boolean(""))
 
225
        self.assertEqual(False, factory.get_boolean(""))
192
226
        self.assertEqual("foo\n", factory.stdin.read())
193
227
        # stdin should be empty
194
228
        self.assertEqual('', factory.stdin.readline())
195
229
 
196
 
    def test_silent_ui_getbool(self):
197
 
        factory = _mod_ui.SilentUIFactory()
198
 
        self.assert_get_bool_acceptance_of_user_input(factory)
199
 
 
200
 
    def test_silent_factory_prompts_silently(self):
201
 
        factory = _mod_ui.SilentUIFactory()
202
 
        stdout = StringIO()
203
 
        factory.stdin = StringIO("y\n")
204
 
        self.assertEqual(True,
205
 
                         self.apply_redirected(None, stdout, stdout,
206
 
                                               factory.get_boolean, "foo"))
207
 
        self.assertEqual("", stdout.getvalue())
208
 
        # stdin should be empty
209
 
        self.assertEqual('', factory.stdin.readline())
210
 
 
211
 
    def test_text_ui_getbool(self):
212
 
        factory = TextUIFactory(None, None, None)
213
 
        self.assert_get_bool_acceptance_of_user_input(factory)
214
 
 
215
230
    def test_text_factory_prompt(self):
216
231
        # see <https://launchpad.net/bugs/365891>
217
 
        factory = TextUIFactory(None, StringIO(), StringIO(), StringIO())
 
232
        factory = TextUIFactory(StringIO(), StringIO(), StringIO())
218
233
        factory.prompt('foo %2e')
219
234
        self.assertEqual('', factory.stdout.getvalue())
220
235
        self.assertEqual('foo %2e', factory.stderr.getvalue())
222
237
    def test_text_factory_prompts_and_clears(self):
223
238
        # a get_boolean call should clear the pb before prompting
224
239
        out = _TTYStringIO()
225
 
        factory = TextUIFactory(stdin=StringIO("yada\ny\n"),
226
 
                                stdout=out, stderr=out)
 
240
        os.environ['TERM'] = 'xterm'
 
241
        factory = TextUIFactory(stdin=StringIO("yada\ny\n"), stdout=out, stderr=out)
227
242
        pb = factory.nested_progress_bar()
228
243
        pb.show_bar = False
229
244
        pb.show_spinner = False
253
268
        finally:
254
269
            pb.finished()
255
270
 
256
 
    def test_silent_ui_getusername(self):
257
 
        factory = _mod_ui.SilentUIFactory()
258
 
        factory.stdin = StringIO("someuser\n\n")
259
 
        factory.stdout = StringIO()
260
 
        factory.stderr = StringIO()
261
 
        self.assertEquals(None,
262
 
            factory.get_username(u'Hello\u1234 %(host)s', host=u'some\u1234'))
263
 
        self.assertEquals("", factory.stdout.getvalue())
264
 
        self.assertEquals("", factory.stderr.getvalue())
265
 
        self.assertEquals("someuser\n\n", factory.stdin.getvalue())
266
 
 
267
271
    def test_text_ui_getusername(self):
268
272
        factory = TextUIFactory(None, None, None)
269
273
        factory.stdin = StringIO("someuser\n\n")
297
301
            pb.finished()
298
302
 
299
303
 
300
 
class TestTextProgressView(tests.TestCase):
301
 
    """Tests for text display of progress bars.
302
 
    """
303
 
    # XXX: These might be a bit easier to write if the rendering and
304
 
    # state-maintaining parts of TextProgressView were more separate, and if
305
 
    # the progress task called back directly to its own view not to the ui
306
 
    # factory. -- mbp 20090312
 
304
class CLIUITests(TestCase):
 
305
 
 
306
    def test_cli_factory_deprecated(self):
 
307
        uif = self.applyDeprecated(deprecated_in((1, 18, 0)),
 
308
            CLIUIFactory,
 
309
            StringIO(), StringIO(), StringIO())
 
310
        self.assertIsInstance(uif, UIFactory)
 
311
 
 
312
 
 
313
class SilentUITests(TestCase):
 
314
 
 
315
    def test_silent_factory_get_password(self):
 
316
        # A silent factory that can't do user interaction can't get a
 
317
        # password.  Possibly it should raise a more specific error but it
 
318
        # can't succeed.
 
319
        ui = SilentUIFactory()
 
320
        stdout = StringIO()
 
321
        self.assertRaises(
 
322
            NotImplementedError,
 
323
            self.apply_redirected,
 
324
            None, stdout, stdout, ui.get_password)
 
325
        # and it didn't write anything out either
 
326
        self.assertEqual('', stdout.getvalue())
 
327
 
 
328
    def test_silent_ui_getbool(self):
 
329
        factory = SilentUIFactory()
 
330
        stdout = StringIO()
 
331
        self.assertRaises(
 
332
            NotImplementedError,
 
333
            self.apply_redirected,
 
334
            None, stdout, stdout, factory.get_boolean, "foo")
 
335
 
 
336
 
 
337
class CannedInputUIFactoryTests(TestCase):
307
338
    
308
 
    def _make_factory(self):
309
 
        out = StringIO()
310
 
        uif = TextUIFactory(stderr=out)
311
 
        uif._progress_view._width = 80
312
 
        return out, uif
313
 
 
314
 
    def test_render_progress_easy(self):
315
 
        """Just one task and one quarter done"""
316
 
        out, uif = self._make_factory()
317
 
        task = uif.nested_progress_bar()
318
 
        task.update('reticulating splines', 5, 20)
319
 
        self.assertEqual(
320
 
'\r[####/               ] reticulating splines 5/20                               \r'
321
 
            , out.getvalue())
322
 
 
323
 
    def test_render_progress_nested(self):
324
 
        """Tasks proportionally contribute to overall progress"""
325
 
        out, uif = self._make_factory()
326
 
        task = uif.nested_progress_bar()
327
 
        task.update('reticulating splines', 0, 2)
328
 
        task2 = uif.nested_progress_bar()
329
 
        task2.update('stage2', 1, 2)
330
 
        # so we're in the first half of the main task, and half way through
331
 
        # that
332
 
        self.assertEqual(
333
 
r'[####\               ] reticulating splines:stage2 1/2'
334
 
            , uif._progress_view._render_line())
335
 
        # if the nested task is complete, then we're all the way through the
336
 
        # first half of the overall work
337
 
        task2.update('stage2', 2, 2)
338
 
        self.assertEqual(
339
 
r'[#########|          ] reticulating splines:stage2 2/2'
340
 
            , uif._progress_view._render_line())
341
 
 
342
 
    def test_render_progress_sub_nested(self):
343
 
        """Intermediate tasks don't mess up calculation."""
344
 
        out, uif = self._make_factory()
345
 
        task_a = uif.nested_progress_bar()
346
 
        task_a.update('a', 0, 2)
347
 
        task_b = uif.nested_progress_bar()
348
 
        task_b.update('b')
349
 
        task_c = uif.nested_progress_bar()
350
 
        task_c.update('c', 1, 2)
351
 
        # the top-level task is in its first half; the middle one has no
352
 
        # progress indication, just a label; and the bottom one is half done,
353
 
        # so the overall fraction is 1/4
354
 
        self.assertEqual(
355
 
            r'[####|               ] a:b:c 1/2'
356
 
            , uif._progress_view._render_line())
357
 
 
 
339
    def test_canned_input_get_input(self):
 
340
        uif = CannedInputUIFactory([True, 'mbp', 'password'])
 
341
        self.assertEqual(uif.get_boolean('Extra cheese?'), True)
 
342
        self.assertEqual(uif.get_username('Enter your user name'), 'mbp')
 
343
        self.assertEqual(uif.get_password('Password for %(host)s', host='example.com'),
 
344
            'password')
 
345
 
 
346
 
 
347
class TestBoolFromString(tests.TestCase):
 
348
 
 
349
    def assertIsTrue(self, s, accepted_values=None):
 
350
        res = _mod_ui.bool_from_string(s, accepted_values=accepted_values)
 
351
        self.assertEquals(True, res)
 
352
 
 
353
    def assertIsFalse(self, s, accepted_values=None):
 
354
        res = _mod_ui.bool_from_string(s, accepted_values=accepted_values)
 
355
        self.assertEquals(False, res)
 
356
 
 
357
    def assertIsNone(self, s, accepted_values=None):
 
358
        res = _mod_ui.bool_from_string(s, accepted_values=accepted_values)
 
359
        self.assertIs(None, res)
 
360
 
 
361
    def test_know_valid_values(self):
 
362
        self.assertIsTrue('true')
 
363
        self.assertIsFalse('false')
 
364
        self.assertIsTrue('1')
 
365
        self.assertIsFalse('0')
 
366
        self.assertIsTrue('on')
 
367
        self.assertIsFalse('off')
 
368
        self.assertIsTrue('yes')
 
369
        self.assertIsFalse('no')
 
370
        self.assertIsTrue('y')
 
371
        self.assertIsFalse('n')
 
372
        # Also try some case variations
 
373
        self.assertIsTrue('True')
 
374
        self.assertIsFalse('False')
 
375
        self.assertIsTrue('On')
 
376
        self.assertIsFalse('Off')
 
377
        self.assertIsTrue('ON')
 
378
        self.assertIsFalse('OFF')
 
379
        self.assertIsTrue('oN')
 
380
        self.assertIsFalse('oFf')
 
381
 
 
382
    def test_invalid_values(self):
 
383
        self.assertIsNone(None)
 
384
        self.assertIsNone('doubt')
 
385
        self.assertIsNone('frue')
 
386
        self.assertIsNone('talse')
 
387
        self.assertIsNone('42')
 
388
 
 
389
    def test_provided_values(self):
 
390
        av = dict(y=True, n=False, yes=True, no=False)
 
391
        self.assertIsTrue('y', av)
 
392
        self.assertIsTrue('Y', av)
 
393
        self.assertIsTrue('Yes', av)
 
394
        self.assertIsFalse('n', av)
 
395
        self.assertIsFalse('N', av)
 
396
        self.assertIsFalse('No', av)
 
397
        self.assertIsNone('1', av)
 
398
        self.assertIsNone('0', av)
 
399
        self.assertIsNone('on', av)
 
400
        self.assertIsNone('off', av)