/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_ui.py

Merge bzr.dev, update to use new hooks.

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
20
import time
22
21
 
23
22
from StringIO import StringIO
26
25
 
27
26
from bzrlib import (
28
27
    config,
29
 
    errors,
30
28
    remote,
31
 
    repository,
32
29
    tests,
33
30
    ui as _mod_ui,
34
31
    )
35
 
from bzrlib.symbol_versioning import (
36
 
    deprecated_in,
37
 
    )
38
32
from bzrlib.tests import (
39
33
    fixtures,
40
34
    test_progress,
69
63
    def test_text_factory_confirm(self):
70
64
        # turns into reading a regular boolean
71
65
        ui = self.make_test_ui_factory('n\n')
72
 
        self.assertEquals(ui.confirm_action('Should %(thing)s pass?',
 
66
        self.assertEquals(ui.confirm_action(u'Should %(thing)s pass?',
73
67
            'bzrlib.tests.test_ui.confirmation',
74
68
            {'thing': 'this'},),
75
69
            False)
117
111
    def test_text_ui_get_boolean(self):
118
112
        stdin = tests.StringIOWrapper("y\n" # True
119
113
                                      "n\n" # False
 
114
                                      " \n y \n" # True
 
115
                                      " no \n" # False
120
116
                                      "yes with garbage\nY\n" # True
121
117
                                      "not an answer\nno\n" # False
122
118
                                      "I'm sure!\nyes\n" # True
125
121
        stdout = tests.StringIOWrapper()
126
122
        stderr = tests.StringIOWrapper()
127
123
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
128
 
        self.assertEqual(True, factory.get_boolean(""))
129
 
        self.assertEqual(False, factory.get_boolean(""))
130
 
        self.assertEqual(True, factory.get_boolean(""))
131
 
        self.assertEqual(False, factory.get_boolean(""))
132
 
        self.assertEqual(True, factory.get_boolean(""))
133
 
        self.assertEqual(False, factory.get_boolean(""))
134
 
        self.assertEqual("foo\n", factory.stdin.read())
135
 
        # stdin should be empty
136
 
        self.assertEqual('', factory.stdin.readline())
 
124
        self.assertEqual(True, factory.get_boolean(u""))
 
125
        self.assertEqual(False, factory.get_boolean(u""))
 
126
        self.assertEqual(True, factory.get_boolean(u""))
 
127
        self.assertEqual(False, factory.get_boolean(u""))
 
128
        self.assertEqual(True, factory.get_boolean(u""))
 
129
        self.assertEqual(False, factory.get_boolean(u""))
 
130
        self.assertEqual(True, factory.get_boolean(u""))
 
131
        self.assertEqual(False, factory.get_boolean(u""))
 
132
        self.assertEqual("foo\n", factory.stdin.read())
 
133
        # stdin should be empty
 
134
        self.assertEqual('', factory.stdin.readline())
 
135
        # return false on EOF
 
136
        self.assertEqual(False, factory.get_boolean(u""))
 
137
 
 
138
    def test_text_ui_choose_bad_parameters(self):
 
139
        stdin = tests.StringIOWrapper()
 
140
        stdout = tests.StringIOWrapper()
 
141
        stderr = tests.StringIOWrapper()
 
142
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
 
143
        # invalid default index
 
144
        self.assertRaises(ValueError, factory.choose, u"", u"&Yes\n&No", 3)
 
145
        # duplicated choice
 
146
        self.assertRaises(ValueError, factory.choose, u"", u"&choice\n&ChOiCe")
 
147
        # duplicated shortcut
 
148
        self.assertRaises(ValueError, factory.choose, u"", u"&choice1\nchoi&ce2")
 
149
 
 
150
    def test_text_ui_choose_prompt(self):
 
151
        stdin = tests.StringIOWrapper()
 
152
        stdout = tests.StringIOWrapper()
 
153
        stderr = tests.StringIOWrapper()
 
154
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
 
155
        # choices with explicit shortcuts
 
156
        factory.choose(u"prompt", u"&yes\n&No\nmore &info")
 
157
        self.assertEqual("prompt ([y]es, [N]o, more [i]nfo): \n", factory.stderr.getvalue())
 
158
        # automatic shortcuts
 
159
        factory.stderr.truncate(0)
 
160
        factory.choose(u"prompt", u"yes\nNo\nmore info")
 
161
        self.assertEqual("prompt ([y]es, [N]o, [m]ore info): \n", factory.stderr.getvalue())
 
162
 
 
163
    def test_text_ui_choose_return_values(self):
 
164
        choose = lambda: factory.choose(u"", u"&Yes\n&No\nMaybe\nmore &info", 3)
 
165
        stdin = tests.StringIOWrapper("y\n" # 0
 
166
                                      "n\n" # 1
 
167
                                      " \n" # default: 3
 
168
                                      " no \n" # 1
 
169
                                      "b\na\nd \n" # bad shortcuts, all ignored
 
170
                                      "yes with garbage\nY\n" # 0
 
171
                                      "not an answer\nno\n" # 1
 
172
                                      "info\nmore info\n" # 3
 
173
                                      "Maybe\n" # 2
 
174
                                      "foo\n")
 
175
        stdout = tests.StringIOWrapper()
 
176
        stderr = tests.StringIOWrapper()
 
177
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
 
178
        self.assertEqual(0, choose())
 
179
        self.assertEqual(1, choose())
 
180
        self.assertEqual(3, choose())
 
181
        self.assertEqual(1, choose())
 
182
        self.assertEqual(0, choose())
 
183
        self.assertEqual(1, choose())
 
184
        self.assertEqual(3, choose())
 
185
        self.assertEqual(2, choose())
 
186
        self.assertEqual("foo\n", factory.stdin.read())
 
187
        # stdin should be empty
 
188
        self.assertEqual('', factory.stdin.readline())
 
189
        # return None on EOF
 
190
        self.assertEqual(None, choose())
 
191
 
 
192
    def test_text_ui_choose_no_default(self):
 
193
        stdin = tests.StringIOWrapper(" \n" # no default, invalid!
 
194
                                      " yes \n" # 0
 
195
                                      "foo\n")
 
196
        stdout = tests.StringIOWrapper()
 
197
        stderr = tests.StringIOWrapper()
 
198
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
 
199
        self.assertEqual(0, factory.choose(u"", u"&Yes\n&No"))
 
200
        self.assertEqual("foo\n", factory.stdin.read())
137
201
 
138
202
    def test_text_ui_get_integer(self):
139
203
        stdin = tests.StringIOWrapper(
143
207
        stdout = tests.StringIOWrapper()
144
208
        stderr = tests.StringIOWrapper()
145
209
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
146
 
        self.assertEqual(1, factory.get_integer(""))
147
 
        self.assertEqual(-2, factory.get_integer(""))
148
 
        self.assertEqual(42, factory.get_integer(""))
 
210
        self.assertEqual(1, factory.get_integer(u""))
 
211
        self.assertEqual(-2, factory.get_integer(u""))
 
212
        self.assertEqual(42, factory.get_integer(u""))
149
213
 
150
214
    def test_text_factory_prompt(self):
151
215
        # see <https://launchpad.net/bugs/365891>
152
216
        StringIO = tests.StringIOWrapper
153
217
        factory = _mod_ui_text.TextUIFactory(StringIO(), StringIO(), StringIO())
154
 
        factory.prompt('foo %2e')
 
218
        factory.prompt(u'foo %2e')
155
219
        self.assertEqual('', factory.stdout.getvalue())
156
220
        self.assertEqual('foo %2e', factory.stderr.getvalue())
157
221
 
158
222
    def test_text_factory_prompts_and_clears(self):
159
223
        # a get_boolean call should clear the pb before prompting
160
224
        out = test_progress._TTYStringIO()
161
 
        os.environ['TERM'] = 'xterm'
 
225
        self.overrideEnv('TERM', 'xterm')
162
226
        factory = _mod_ui_text.TextUIFactory(
163
227
            stdin=tests.StringIOWrapper("yada\ny\n"),
164
228
            stdout=out, stderr=out)
172
236
                         self.apply_redirected(None, factory.stdout,
173
237
                                               factory.stdout,
174
238
                                               factory.get_boolean,
175
 
                                               "what do you want"))
 
239
                                               u"what do you want"))
176
240
        output = out.getvalue()
177
241
        self.assertContainsRe(output,
178
242
            "| foo *\r\r  *\r*")
179
 
        self.assertContainsRe(output,
180
 
            r"what do you want\? \[y/n\]: what do you want\? \[y/n\]: ")
 
243
        self.assertContainsString(output,
 
244
            r"what do you want? ([y]es, [n]o): what do you want? ([y]es, [n]o): ")
181
245
        # stdin should have been totally consumed
182
246
        self.assertEqual('', factory.stdin.readline())
183
247
 
201
265
        factory.stdout.encoding = "utf8"
202
266
        # there is no output from the base factory
203
267
        self.assertEqual("someuser",
204
 
                         factory.get_username('Hello %(host)s', host='some'))
 
268
                         factory.get_username(u'Hello %(host)s', host='some'))
205
269
        self.assertEquals("Hello some: ", factory.stderr.getvalue())
206
270
        self.assertEquals('', factory.stdout.getvalue())
207
 
        self.assertEqual("", factory.get_username("Gebruiker"))
 
271
        self.assertEqual("", factory.get_username(u"Gebruiker"))
208
272
        # stdin should be empty
209
273
        self.assertEqual('', factory.stdin.readline())
210
274
 
226
290
            pb.finished()
227
291
 
228
292
    def test_quietness(self):
229
 
        os.environ['BZR_PROGRESS_BAR'] = 'text'
 
293
        self.overrideEnv('BZR_PROGRESS_BAR', 'text')
230
294
        ui_factory = _mod_ui_text.TextUIFactory(None,
231
295
            test_progress._TTYStringIO(),
232
296
            test_progress._TTYStringIO())
238
302
 
239
303
    def test_text_ui_show_user_warning(self):
240
304
        from bzrlib.repofmt.groupcompress_repo import RepositoryFormat2a
241
 
        from bzrlib.repofmt.pack_repo import RepositoryFormatKnitPack5
 
305
        from bzrlib.repofmt.knitpack_repo import RepositoryFormatKnitPack5
242
306
        err = StringIO()
243
307
        out = StringIO()
244
308
        ui = tests.TextUIFactory(stdin=None, stdout=out, stderr=err)
313
377
            # however, it can still be forced on
314
378
            (FileStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),
315
379
            ):
316
 
            os.environ['TERM'] = term
317
 
            if pb is None:
318
 
                if 'BZR_PROGRESS_BAR' in os.environ:
319
 
                    del os.environ['BZR_PROGRESS_BAR']
320
 
            else:
321
 
                os.environ['BZR_PROGRESS_BAR'] = pb
 
380
            self.overrideEnv('TERM', term)
 
381
            self.overrideEnv('BZR_PROGRESS_BAR', pb)
322
382
            stdin = file_class('')
323
383
            stderr = file_class()
324
384
            stdout = file_class()
335
395
        stderr = test_progress._NonTTYStringIO()
336
396
        stdout = test_progress._NonTTYStringIO()
337
397
        for term_type in ['dumb', None, 'xterm']:
338
 
            if term_type is None:
339
 
                del os.environ['TERM']
340
 
            else:
341
 
                os.environ['TERM'] = term_type
 
398
            self.overrideEnv('TERM', term_type)
342
399
            uif = _mod_ui.make_ui_for_terminal(stdin, stdout, stderr)
343
400
            self.assertIsInstance(uif, _mod_ui_text.TextUIFactory,
344
401
                'TERM=%r' % (term_type,))
365
422
        self.assertRaises(
366
423
            NotImplementedError,
367
424
            self.apply_redirected,
368
 
            None, stdout, stdout, factory.get_boolean, "foo")
 
425
            None, stdout, stdout, factory.get_boolean, u"foo")
369
426
 
370
427
 
371
428
class TestUIFactoryTests(tests.TestCase):
384
441
 
385
442
    def test_canned_input_get_input(self):
386
443
        uif = _mod_ui.CannedInputUIFactory([True, 'mbp', 'password', 42])
387
 
        self.assertEqual(True, uif.get_boolean('Extra cheese?'))
388
 
        self.assertEqual('mbp', uif.get_username('Enter your user name'))
 
444
        self.assertEqual(True, uif.get_boolean(u'Extra cheese?'))
 
445
        self.assertEqual('mbp', uif.get_username(u'Enter your user name'))
389
446
        self.assertEqual('password',
390
 
                         uif.get_password('Password for %(host)s',
 
447
                         uif.get_password(u'Password for %(host)s',
391
448
                                          host='example.com'))
392
 
        self.assertEqual(42, uif.get_integer('And all that jazz ?'))
 
449
        self.assertEqual(42, uif.get_integer(u'And all that jazz ?'))
393
450
 
394
451
 
395
452
class TestBoolFromString(tests.TestCase):