/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

  • Committer: Martin Pool
  • Date: 2009-12-14 06:06:59 UTC
  • mfrom: (4889 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4891.
  • Revision ID: mbp@sourcefrog.net-20091214060659-1ucv8hpnky0cbnaj
merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_ui.py
1
 
# Copyright (C) 2005 Canonical Ltd
 
1
# Copyright (C) 2005, 2008, 2009 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tests for the bzrlib ui
18
18
"""
19
19
 
20
20
import os
21
 
from StringIO import StringIO
22
21
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())
 
22
import time
 
23
 
 
24
from bzrlib import (
 
25
    errors,
 
26
    tests,
 
27
    ui as _mod_ui,
 
28
    )
 
29
from bzrlib.symbol_versioning import (
 
30
    deprecated_in,
 
31
    )
 
32
from bzrlib.tests import test_progress
 
33
from bzrlib.ui import text as _mod_ui_text
 
34
 
 
35
 
 
36
class TestTextUIFactory(tests.TestCase):
60
37
 
61
38
    def test_text_factory_ascii_password(self):
62
 
        ui = TestUIFactory(stdin='secret\n', stdout=StringIOWrapper())
 
39
        ui = tests.TestUIFactory(stdin='secret\n',
 
40
                                 stdout=tests.StringIOWrapper(),
 
41
                                 stderr=tests.StringIOWrapper())
63
42
        pb = ui.nested_progress_bar()
64
43
        try:
65
44
            self.assertEqual('secret',
66
45
                             self.apply_redirected(ui.stdin, ui.stdout,
67
 
                                                   ui.stdout,
 
46
                                                   ui.stderr,
68
47
                                                   ui.get_password))
69
48
            # ': ' is appended to prompt
70
 
            self.assertEqual(': ', ui.stdout.getvalue())
 
49
            self.assertEqual(': ', ui.stderr.getvalue())
 
50
            self.assertEqual('', ui.stdout.readline())
71
51
            # stdin should be empty
72
52
            self.assertEqual('', ui.stdin.readline())
73
53
        finally:
79
59
        We can't predict what encoding users will have for stdin, so we force
80
60
        it to utf8 to test that we transport the password correctly.
81
61
        """
82
 
        ui = TestUIFactory(stdin=u'baz\u1234'.encode('utf8'),
83
 
                           stdout=StringIOWrapper())
84
 
        ui.stdin.encoding = 'utf8'
85
 
        ui.stdout.encoding = ui.stdin.encoding
 
62
        ui = tests.TestUIFactory(stdin=u'baz\u1234'.encode('utf8'),
 
63
                                 stdout=tests.StringIOWrapper(),
 
64
                                 stderr=tests.StringIOWrapper())
 
65
        ui.stderr.encoding = ui.stdout.encoding = ui.stdin.encoding = 'utf8'
86
66
        pb = ui.nested_progress_bar()
87
67
        try:
88
 
            password = self.apply_redirected(ui.stdin, ui.stdout, ui.stdout,
 
68
            password = self.apply_redirected(ui.stdin, ui.stdout, ui.stderr,
89
69
                                             ui.get_password,
90
70
                                             u'Hello \u1234 %(user)s',
91
71
                                             user=u'some\u1234')
92
72
            # We use StringIO objects, we need to decode them
93
73
            self.assertEqual(u'baz\u1234', password.decode('utf8'))
94
74
            self.assertEqual(u'Hello \u1234 some\u1234: ',
95
 
                             ui.stdout.getvalue().decode('utf8'))
96
 
            # stdin should be empty
 
75
                             ui.stderr.getvalue().decode('utf8'))
 
76
            # stdin and stdout should be empty
97
77
            self.assertEqual('', ui.stdin.readline())
 
78
            self.assertEqual('', ui.stdout.readline())
98
79
        finally:
99
80
            pb.finished()
100
81
 
101
82
    def test_progress_note(self):
102
 
        stderr = StringIO()
103
 
        stdout = StringIO()
104
 
        ui_factory = TextUIFactory(bar_type=TTYProgressBar)
 
83
        stderr = tests.StringIOWrapper()
 
84
        stdout = tests.StringIOWrapper()
 
85
        ui_factory = _mod_ui_text.TextUIFactory(stdin=tests.StringIOWrapper(''),
 
86
                                                stderr=stderr,
 
87
                                                stdout=stdout)
105
88
        pb = ui_factory.nested_progress_bar()
106
89
        try:
107
 
            pb.to_messages_file = stdout
108
 
            ui_factory._progress_bar_stack.bottom().to_file = stderr
109
 
            result = pb.note('t')
 
90
            result = self.applyDeprecated(deprecated_in((2, 1, 0)),
 
91
                pb.note,
 
92
                't')
110
93
            self.assertEqual(None, result)
111
94
            self.assertEqual("t\n", stdout.getvalue())
112
95
            # Since there was no update() call, there should be no clear() call
117
100
            pb.finished()
118
101
 
119
102
    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)
 
103
        stderr = test_progress._TTYStringIO()
 
104
        stdout = test_progress._TTYStringIO()
 
105
        # so that we get a TextProgressBar
 
106
        os.environ['TERM'] = 'xterm'
 
107
        ui_factory = _mod_ui_text.TextUIFactory(
 
108
            stdin=tests.StringIOWrapper(''),
 
109
            stdout=stdout, stderr=stderr)
 
110
        self.assertIsInstance(ui_factory._progress_view,
 
111
                              _mod_ui_text.TextProgressView)
126
112
        pb = ui_factory.nested_progress_bar()
127
113
        try:
128
 
            pb.to_messages_file = stdout
129
 
            ui_factory._progress_bar_stack.bottom().to_file = stderr
130
114
            # Create a progress update that isn't throttled
131
 
            pb.start_time -= 10
132
115
            pb.update('x', 1, 1)
133
 
            result = pb.note('t')
 
116
            result = self.applyDeprecated(deprecated_in((2, 1, 0)),
 
117
                pb.note, 't')
134
118
            self.assertEqual(None, result)
135
119
            self.assertEqual("t\n", stdout.getvalue())
136
120
            # the exact contents will depend on the terminal width and we don't
142
126
 
143
127
    def test_progress_nested(self):
144
128
        # test factory based nested and popping.
145
 
        ui = TextUIFactory()
 
129
        ui = _mod_ui_text.TextUIFactory(None, None, None)
146
130
        pb1 = ui.nested_progress_bar()
147
131
        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(""))
 
132
        # You do get a warning if the outermost progress bar wasn't finished
 
133
        # first - it's not clear if this is really useful or if it should just
 
134
        # become orphaned -- mbp 20090120
 
135
        warnings, _ = self.callCatchWarnings(pb1.finished)
 
136
        if len(warnings) != 1:
 
137
            self.fail("unexpected warnings: %r" % (warnings,))
 
138
        pb2.finished()
 
139
        pb1.finished()
 
140
 
 
141
    def test_text_ui_get_boolean(self):
 
142
        stdin = tests.StringIOWrapper("y\n" # True
 
143
                                      "n\n" # False
 
144
                                      "yes with garbage\nY\n" # True
 
145
                                      "not an answer\nno\n" # False
 
146
                                      "I'm sure!\nyes\n" # True
 
147
                                      "NO\n" # False
 
148
                                      "foo\n")
 
149
        stdout = tests.StringIOWrapper()
 
150
        stderr = tests.StringIOWrapper()
 
151
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
 
152
        self.assertEqual(True, factory.get_boolean(""))
 
153
        self.assertEqual(False, factory.get_boolean(""))
 
154
        self.assertEqual(True, factory.get_boolean(""))
 
155
        self.assertEqual(False, factory.get_boolean(""))
 
156
        self.assertEqual(True, factory.get_boolean(""))
194
157
        self.assertEqual(False, factory.get_boolean(""))
195
158
        self.assertEqual("foo\n", factory.stdin.read())
196
159
        # stdin should be empty
197
160
        self.assertEqual('', factory.stdin.readline())
198
161
 
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)
 
162
    def test_text_ui_get_integer(self):
 
163
        stdin = tests.StringIOWrapper(
 
164
            "1\n"
 
165
            "  -2  \n"
 
166
            "hmmm\nwhat else ?\nCome on\nok 42\n4.24\n42\n")
 
167
        stdout = tests.StringIOWrapper()
 
168
        stderr = tests.StringIOWrapper()
 
169
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
 
170
        self.assertEqual(1, factory.get_integer(""))
 
171
        self.assertEqual(-2, factory.get_integer(""))
 
172
        self.assertEqual(42, factory.get_integer(""))
 
173
 
 
174
    def test_text_factory_prompt(self):
 
175
        # see <https://launchpad.net/bugs/365891>
 
176
        StringIO = tests.StringIOWrapper
 
177
        factory = _mod_ui_text.TextUIFactory(StringIO(), StringIO(), StringIO())
 
178
        factory.prompt('foo %2e')
 
179
        self.assertEqual('', factory.stdout.getvalue())
 
180
        self.assertEqual('foo %2e', factory.stderr.getvalue())
217
181
 
218
182
    def test_text_factory_prompts_and_clears(self):
219
183
        # 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)
 
184
        out = test_progress._TTYStringIO()
 
185
        os.environ['TERM'] = 'xterm'
 
186
        factory = _mod_ui_text.TextUIFactory(
 
187
            stdin=tests.StringIOWrapper("yada\ny\n"),
 
188
            stdout=out, stderr=out)
 
189
        pb = factory.nested_progress_bar()
 
190
        pb.show_bar = False
 
191
        pb.show_spinner = False
 
192
        pb.show_count = False
 
193
        pb.update("foo", 0, 1)
228
194
        self.assertEqual(True,
229
195
                         self.apply_redirected(None, factory.stdout,
230
196
                                               factory.stdout,
231
197
                                               factory.get_boolean,
232
198
                                               "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())
 
199
        output = out.getvalue()
 
200
        self.assertContainsRe(factory.stdout.getvalue(),
 
201
            "foo *\r\r  *\r*")
 
202
        self.assertContainsRe(factory.stdout.getvalue(),
 
203
            r"what do you want\? \[y/n\]: what do you want\? \[y/n\]: ")
 
204
        # stdin should have been totally consumed
 
205
        self.assertEqual('', factory.stdin.readline())
 
206
 
 
207
    def test_text_tick_after_update(self):
 
208
        ui_factory = _mod_ui_text.TextUIFactory(stdout=tests.StringIOWrapper(),
 
209
                                                stderr=tests.StringIOWrapper())
 
210
        pb = ui_factory.nested_progress_bar()
 
211
        try:
 
212
            pb.update('task', 0, 3)
 
213
            # Reset the clock, so that it actually tries to repaint itself
 
214
            ui_factory._progress_view._last_repaint = time.time() - 1.0
 
215
            pb.tick()
 
216
        finally:
 
217
            pb.finished()
 
218
 
 
219
    def test_text_ui_getusername(self):
 
220
        factory = _mod_ui_text.TextUIFactory(None, None, None)
 
221
        factory.stdin = tests.StringIOWrapper("someuser\n\n")
 
222
        factory.stdout = tests.StringIOWrapper()
 
223
        factory.stderr = tests.StringIOWrapper()
 
224
        factory.stdout.encoding = "utf8"
 
225
        # there is no output from the base factory
 
226
        self.assertEqual("someuser",
 
227
                         factory.get_username('Hello %(host)s', host='some'))
 
228
        self.assertEquals("Hello some: ", factory.stderr.getvalue())
 
229
        self.assertEquals('', factory.stdout.getvalue())
 
230
        self.assertEqual("", factory.get_username("Gebruiker"))
237
231
        # stdin should be empty
238
232
        self.assertEqual('', factory.stdin.readline())
239
233
 
 
234
    def test_text_ui_getusername_utf8(self):
 
235
        ui = tests.TestUIFactory(stdin=u'someuser\u1234'.encode('utf8'),
 
236
                                 stdout=tests.StringIOWrapper(),
 
237
                                 stderr=tests.StringIOWrapper())
 
238
        ui.stderr.encoding = ui.stdout.encoding = ui.stdin.encoding = "utf8"
 
239
        pb = ui.nested_progress_bar()
 
240
        try:
 
241
            # there is no output from the base factory
 
242
            username = self.apply_redirected(ui.stdin, ui.stdout, ui.stderr,
 
243
                ui.get_username, u'Hello\u1234 %(host)s', host=u'some\u1234')
 
244
            self.assertEquals(u"someuser\u1234", username.decode('utf8'))
 
245
            self.assertEquals(u"Hello\u1234 some\u1234: ",
 
246
                              ui.stderr.getvalue().decode("utf8"))
 
247
            self.assertEquals('', ui.stdout.getvalue())
 
248
        finally:
 
249
            pb.finished()
 
250
 
 
251
 
 
252
class TestTextUIOutputStream(tests.TestCase):
 
253
    """Tests for output stream that synchronizes with progress bar."""
 
254
 
 
255
    def test_output_clears_terminal(self):
 
256
        stdout = tests.StringIOWrapper()
 
257
        stderr = tests.StringIOWrapper()
 
258
        clear_calls = []
 
259
 
 
260
        uif =  _mod_ui_text.TextUIFactory(None, stdout, stderr)
 
261
        uif.clear_term = lambda: clear_calls.append('clear')
 
262
 
 
263
        stream = _mod_ui_text.TextUIOutputStream(uif, uif.stdout)
 
264
        stream.write("Hello world!\n")
 
265
        stream.write("there's more...\n")
 
266
        stream.writelines(["1\n", "2\n", "3\n"])
 
267
 
 
268
        self.assertEqual(stdout.getvalue(),
 
269
            "Hello world!\n"
 
270
            "there's more...\n"
 
271
            "1\n2\n3\n")
 
272
        self.assertEqual(['clear', 'clear', 'clear'],
 
273
            clear_calls)
 
274
 
 
275
        stream.flush()
 
276
 
 
277
 
 
278
class UITests(tests.TestCase):
 
279
 
 
280
    def test_progress_construction(self):
 
281
        """TextUIFactory constructs the right progress view.
 
282
        """
 
283
        TTYStringIO = test_progress._TTYStringIO
 
284
        FileStringIO = tests.StringIOWrapper
 
285
        for (file_class, term, pb, expected_pb_class) in (
 
286
            # on an xterm, either use them or not as the user requests,
 
287
            # otherwise default on
 
288
            (TTYStringIO, 'xterm', 'none', _mod_ui_text.NullProgressView),
 
289
            (TTYStringIO, 'xterm', 'text', _mod_ui_text.TextProgressView),
 
290
            (TTYStringIO, 'xterm', None, _mod_ui_text.TextProgressView),
 
291
            # on a dumb terminal, again if there's explicit configuration do
 
292
            # it, otherwise default off
 
293
            (TTYStringIO, 'dumb', 'none', _mod_ui_text.NullProgressView),
 
294
            (TTYStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),
 
295
            (TTYStringIO, 'dumb', None, _mod_ui_text.NullProgressView),
 
296
            # on a non-tty terminal, it's null regardless of $TERM
 
297
            (FileStringIO, 'xterm', None, _mod_ui_text.NullProgressView),
 
298
            (FileStringIO, 'dumb', None, _mod_ui_text.NullProgressView),
 
299
            # however, it can still be forced on
 
300
            (FileStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),
 
301
            ):
 
302
            os.environ['TERM'] = term
 
303
            if pb is None:
 
304
                if 'BZR_PROGRESS_BAR' in os.environ:
 
305
                    del os.environ['BZR_PROGRESS_BAR']
 
306
            else:
 
307
                os.environ['BZR_PROGRESS_BAR'] = pb
 
308
            stdin = file_class('')
 
309
            stderr = file_class()
 
310
            stdout = file_class()
 
311
            uif = _mod_ui.make_ui_for_terminal(stdin, stdout, stderr)
 
312
            self.assertIsInstance(uif, _mod_ui_text.TextUIFactory,
 
313
                "TERM=%s BZR_PROGRESS_BAR=%s uif=%r" % (term, pb, uif,))
 
314
            self.assertIsInstance(uif.make_progress_view(),
 
315
                expected_pb_class,
 
316
                "TERM=%s BZR_PROGRESS_BAR=%s uif=%r" % (term, pb, uif,))
 
317
 
 
318
    def test_text_ui_non_terminal(self):
 
319
        """Even on non-ttys, make_ui_for_terminal gives a text ui."""
 
320
        stdin = test_progress._NonTTYStringIO('')
 
321
        stderr = test_progress._NonTTYStringIO()
 
322
        stdout = test_progress._NonTTYStringIO()
 
323
        for term_type in ['dumb', None, 'xterm']:
 
324
            if term_type is None:
 
325
                del os.environ['TERM']
 
326
            else:
 
327
                os.environ['TERM'] = term_type
 
328
            uif = _mod_ui.make_ui_for_terminal(stdin, stdout, stderr)
 
329
            self.assertIsInstance(uif, _mod_ui_text.TextUIFactory,
 
330
                'TERM=%r' % (term_type,))
 
331
 
 
332
 
 
333
class SilentUITests(tests.TestCase):
 
334
 
 
335
    def test_silent_factory_get_password(self):
 
336
        # A silent factory that can't do user interaction can't get a
 
337
        # password.  Possibly it should raise a more specific error but it
 
338
        # can't succeed.
 
339
        ui = _mod_ui.SilentUIFactory()
 
340
        stdout = tests.StringIOWrapper()
 
341
        self.assertRaises(
 
342
            NotImplementedError,
 
343
            self.apply_redirected,
 
344
            None, stdout, stdout, ui.get_password)
 
345
        # and it didn't write anything out either
 
346
        self.assertEqual('', stdout.getvalue())
 
347
 
 
348
    def test_silent_ui_getbool(self):
 
349
        factory = _mod_ui.SilentUIFactory()
 
350
        stdout = tests.StringIOWrapper()
 
351
        self.assertRaises(
 
352
            NotImplementedError,
 
353
            self.apply_redirected,
 
354
            None, stdout, stdout, factory.get_boolean, "foo")
 
355
 
 
356
 
 
357
class TestUIFactoryTests(tests.TestCase):
 
358
 
 
359
    def test_test_ui_factory_progress(self):
 
360
        # there's no output; we just want to make sure this doesn't crash -
 
361
        # see https://bugs.edge.launchpad.net/bzr/+bug/408201
 
362
        ui = tests.TestUIFactory()
 
363
        pb = ui.nested_progress_bar()
 
364
        pb.update('hello')
 
365
        pb.tick()
 
366
        pb.finished()
 
367
 
 
368
 
 
369
class CannedInputUIFactoryTests(tests.TestCase):
 
370
 
 
371
    def test_canned_input_get_input(self):
 
372
        uif = _mod_ui.CannedInputUIFactory([True, 'mbp', 'password', 42])
 
373
        self.assertEqual(True, uif.get_boolean('Extra cheese?'))
 
374
        self.assertEqual('mbp', uif.get_username('Enter your user name'))
 
375
        self.assertEqual('password',
 
376
                         uif.get_password('Password for %(host)s',
 
377
                                          host='example.com'))
 
378
        self.assertEqual(42, uif.get_integer('And all that jazz ?'))
 
379
 
 
380
 
 
381
class TestBoolFromString(tests.TestCase):
 
382
 
 
383
    def assertIsTrue(self, s, accepted_values=None):
 
384
        res = _mod_ui.bool_from_string(s, accepted_values=accepted_values)
 
385
        self.assertEquals(True, res)
 
386
 
 
387
    def assertIsFalse(self, s, accepted_values=None):
 
388
        res = _mod_ui.bool_from_string(s, accepted_values=accepted_values)
 
389
        self.assertEquals(False, res)
 
390
 
 
391
    def assertIsNone(self, s, accepted_values=None):
 
392
        res = _mod_ui.bool_from_string(s, accepted_values=accepted_values)
 
393
        self.assertIs(None, res)
 
394
 
 
395
    def test_know_valid_values(self):
 
396
        self.assertIsTrue('true')
 
397
        self.assertIsFalse('false')
 
398
        self.assertIsTrue('1')
 
399
        self.assertIsFalse('0')
 
400
        self.assertIsTrue('on')
 
401
        self.assertIsFalse('off')
 
402
        self.assertIsTrue('yes')
 
403
        self.assertIsFalse('no')
 
404
        self.assertIsTrue('y')
 
405
        self.assertIsFalse('n')
 
406
        # Also try some case variations
 
407
        self.assertIsTrue('True')
 
408
        self.assertIsFalse('False')
 
409
        self.assertIsTrue('On')
 
410
        self.assertIsFalse('Off')
 
411
        self.assertIsTrue('ON')
 
412
        self.assertIsFalse('OFF')
 
413
        self.assertIsTrue('oN')
 
414
        self.assertIsFalse('oFf')
 
415
 
 
416
    def test_invalid_values(self):
 
417
        self.assertIsNone(None)
 
418
        self.assertIsNone('doubt')
 
419
        self.assertIsNone('frue')
 
420
        self.assertIsNone('talse')
 
421
        self.assertIsNone('42')
 
422
 
 
423
    def test_provided_values(self):
 
424
        av = dict(y=True, n=False, yes=True, no=False)
 
425
        self.assertIsTrue('y', av)
 
426
        self.assertIsTrue('Y', av)
 
427
        self.assertIsTrue('Yes', av)
 
428
        self.assertIsFalse('n', av)
 
429
        self.assertIsFalse('N', av)
 
430
        self.assertIsFalse('No', av)
 
431
        self.assertIsNone('1', av)
 
432
        self.assertIsNone('0', av)
 
433
        self.assertIsNone('on', av)
 
434
        self.assertIsNone('off', av)