/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 breezy/tests/test_ui.py

  • Committer: Breezy landing bot
  • Author(s): Colin Watson
  • Date: 2020-11-16 21:47:08 UTC
  • mfrom: (7521.1.1 remove-lp-workaround)
  • Revision ID: breezy.the.bot@gmail.com-20201116214708-jos209mgxi41oy15
Remove breezy.git workaround for bazaar.launchpad.net.

Merged from https://code.launchpad.net/~cjwatson/brz/remove-lp-workaround/+merge/393710

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_ui.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005-2012, 2016 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
"""Tests for the bzrlib ui
18
 
"""
 
17
"""Tests for the breezy ui."""
19
18
 
20
19
import time
21
20
 
22
 
from StringIO import StringIO
23
 
 
24
21
from testtools.matchers import *
25
22
 
26
 
from bzrlib import (
 
23
from .. import (
27
24
    config,
28
 
    remote,
29
25
    tests,
30
26
    ui as _mod_ui,
31
27
    )
32
 
from bzrlib.tests import (
 
28
from ..bzr import (
 
29
    remote,
 
30
    )
 
31
from . import (
33
32
    fixtures,
 
33
    ui_testing,
34
34
    )
35
 
from bzrlib.ui import text as _mod_ui_text
36
 
from bzrlib.tests.testui import (
 
35
from ..ui import text as _mod_ui_text
 
36
from .testui import (
37
37
    ProgressRecordingUIFactory,
38
38
    )
39
39
 
40
40
 
41
 
class TTYStringIO(StringIO):
42
 
    """A helper class which makes a StringIO look like a terminal"""
43
 
 
44
 
    def isatty(self):
45
 
        return True
46
 
 
47
 
 
48
 
class NonTTYStringIO(StringIO):
49
 
    """Helper that implements isatty() but returns False"""
50
 
 
51
 
    def isatty(self):
52
 
        return False
53
 
 
54
 
 
55
 
class TestUIConfiguration(tests.TestCaseWithTransport):
 
41
class TestUIConfiguration(tests.TestCaseInTempDir):
56
42
 
57
43
    def test_output_encoding_configuration(self):
58
 
        enc = fixtures.generate_unicode_encodings().next()
 
44
        enc = next(fixtures.generate_unicode_encodings())
59
45
        config.GlobalStack().set('output_encoding', enc)
60
 
        ui = tests.TestUIFactory(stdin=None,
61
 
            stdout=tests.StringIOWrapper(),
62
 
            stderr=tests.StringIOWrapper())
 
46
        IO = ui_testing.BytesIOWithEncoding
 
47
        ui = _mod_ui.make_ui_for_terminal(IO(), IO(), IO())
63
48
        output = ui.make_output_stream()
64
 
        self.assertEquals(output.encoding, enc)
 
49
        self.assertEqual(output.encoding, enc)
65
50
 
66
51
 
67
52
class TestTextUIFactory(tests.TestCase):
68
53
 
69
 
    def make_test_ui_factory(self, stdin_contents):
70
 
        ui = tests.TestUIFactory(stdin=stdin_contents,
71
 
                                 stdout=tests.StringIOWrapper(),
72
 
                                 stderr=tests.StringIOWrapper())
73
 
        return ui
74
 
 
75
54
    def test_text_factory_confirm(self):
76
55
        # turns into reading a regular boolean
77
 
        ui = self.make_test_ui_factory('n\n')
78
 
        self.assertEquals(ui.confirm_action(u'Should %(thing)s pass?',
79
 
            'bzrlib.tests.test_ui.confirmation',
80
 
            {'thing': 'this'},),
81
 
            False)
 
56
        with ui_testing.TestUIFactory('n\n') as ui:
 
57
            self.assertEqual(
 
58
                False,
 
59
                ui.confirm_action(
 
60
                    u'Should %(thing)s pass?',
 
61
                    'breezy.tests.test_ui.confirmation',
 
62
                    {'thing': 'this'}))
82
63
 
83
64
    def test_text_factory_ascii_password(self):
84
 
        ui = self.make_test_ui_factory('secret\n')
85
 
        pb = ui.nested_progress_bar()
86
 
        try:
 
65
        ui = ui_testing.TestUIFactory('secret\n')
 
66
        with ui.nested_progress_bar():
87
67
            self.assertEqual('secret',
88
68
                             self.apply_redirected(ui.stdin, ui.stdout,
89
69
                                                   ui.stderr,
93
73
            self.assertEqual('', ui.stdout.readline())
94
74
            # stdin should be empty
95
75
            self.assertEqual('', ui.stdin.readline())
96
 
        finally:
97
 
            pb.finished()
98
76
 
99
 
    def test_text_factory_utf8_password(self):
100
 
        """Test an utf8 password."""
101
 
        ui = _mod_ui_text.TextUIFactory(None, None, None)
102
 
        ui.stdin = tests.StringIOWrapper(u'baz\u1234'.encode('utf8'))
103
 
        ui.stdout = tests.StringIOWrapper()
104
 
        ui.stderr = tests.StringIOWrapper()
105
 
        ui.stderr.encoding = ui.stdout.encoding = ui.stdin.encoding = 'utf8'
106
 
        password = ui.get_password(u'Hello \u1234 %(user)s', user=u'some\u1234')
 
77
    def test_text_factory_unicode_password(self):
 
78
        """Test a unicode password."""
 
79
        ui = ui_testing.TextUIFactory(u'baz\u1234')
 
80
        password = ui.get_password(
 
81
            u'Hello \u1234 %(user)s', user=u'some\u1234')
107
82
        self.assertEqual(u'baz\u1234', password)
108
 
        self.assertEqual(u'Hello \u1234 some\u1234: ',
109
 
                         ui.stderr.getvalue().decode('utf8'))
 
83
        self.assertEqual(u'Hello \u1234 some\u1234: ', ui.stderr.getvalue())
110
84
        # stdin and stdout should be empty
111
85
        self.assertEqual('', ui.stdin.readline())
112
86
        self.assertEqual('', ui.stdout.getvalue())
113
87
 
114
88
    def test_text_ui_get_boolean(self):
115
 
        stdin = tests.StringIOWrapper("y\n" # True
116
 
                                      "n\n" # False
117
 
                                      " \n y \n" # True
118
 
                                      " no \n" # False
119
 
                                      "yes with garbage\nY\n" # True
120
 
                                      "not an answer\nno\n" # False
121
 
                                      "I'm sure!\nyes\n" # True
122
 
                                      "NO\n" # False
123
 
                                      "foo\n")
124
 
        stdout = tests.StringIOWrapper()
125
 
        stderr = tests.StringIOWrapper()
126
 
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
127
 
        self.assertEqual(True, factory.get_boolean(u""))
128
 
        self.assertEqual(False, factory.get_boolean(u""))
129
 
        self.assertEqual(True, factory.get_boolean(u""))
130
 
        self.assertEqual(False, factory.get_boolean(u""))
131
 
        self.assertEqual(True, factory.get_boolean(u""))
132
 
        self.assertEqual(False, factory.get_boolean(u""))
133
 
        self.assertEqual(True, factory.get_boolean(u""))
134
 
        self.assertEqual(False, factory.get_boolean(u""))
135
 
        self.assertEqual("foo\n", factory.stdin.read())
136
 
        # stdin should be empty
137
 
        self.assertEqual('', factory.stdin.readline())
138
 
        # return false on EOF
139
 
        self.assertEqual(False, factory.get_boolean(u""))
 
89
        stdin_text = (
 
90
            "y\n"  # True
 
91
            "n\n"  # False
 
92
            " \n y \n"  # True
 
93
            " no \n"  # False
 
94
            "yes with garbage\nY\n"  # True
 
95
            "not an answer\nno\n"  # False
 
96
            "I'm sure!\nyes\n"  # True
 
97
            "NO\n"  # False
 
98
            "foo\n")
 
99
        with ui_testing.TextUIFactory(stdin_text) as factory:
 
100
            self.assertEqual(True, factory.get_boolean(u""))
 
101
            self.assertEqual(False, factory.get_boolean(u""))
 
102
            self.assertEqual(True, factory.get_boolean(u""))
 
103
            self.assertEqual(False, factory.get_boolean(u""))
 
104
            self.assertEqual(True, factory.get_boolean(u""))
 
105
            self.assertEqual(False, factory.get_boolean(u""))
 
106
            self.assertEqual(True, factory.get_boolean(u""))
 
107
            self.assertEqual(False, factory.get_boolean(u""))
 
108
            self.assertEqual("foo\n", factory.stdin.read())
 
109
            # stdin should be empty
 
110
            self.assertEqual('', factory.stdin.readline())
 
111
            # return false on EOF
 
112
            self.assertEqual(False, factory.get_boolean(u""))
140
113
 
141
114
    def test_text_ui_choose_bad_parameters(self):
142
 
        stdin = tests.StringIOWrapper()
143
 
        stdout = tests.StringIOWrapper()
144
 
        stderr = tests.StringIOWrapper()
145
 
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
146
 
        # invalid default index
147
 
        self.assertRaises(ValueError, factory.choose, u"", u"&Yes\n&No", 3)
148
 
        # duplicated choice
149
 
        self.assertRaises(ValueError, factory.choose, u"", u"&choice\n&ChOiCe")
150
 
        # duplicated shortcut
151
 
        self.assertRaises(ValueError, factory.choose, u"", u"&choice1\nchoi&ce2")
 
115
        with ui_testing.TextUIFactory(u"") as factory:
 
116
            # invalid default index
 
117
            self.assertRaises(ValueError, factory.choose, u"", u"&Yes\n&No", 3)
 
118
            # duplicated choice
 
119
            self.assertRaises(
 
120
                ValueError, factory.choose, u"", u"&choice\n&ChOiCe")
 
121
            # duplicated shortcut
 
122
            self.assertRaises(
 
123
                ValueError, factory.choose, u"", u"&choice1\nchoi&ce2")
152
124
 
153
 
    def test_text_ui_choose_prompt(self):
154
 
        stdin = tests.StringIOWrapper()
155
 
        stdout = tests.StringIOWrapper()
156
 
        stderr = tests.StringIOWrapper()
157
 
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
 
125
    def test_text_ui_choose_prompt_explicit(self):
158
126
        # choices with explicit shortcuts
159
 
        factory.choose(u"prompt", u"&yes\n&No\nmore &info")
160
 
        self.assertEqual("prompt ([y]es, [N]o, more [i]nfo): \n", factory.stderr.getvalue())
 
127
        with ui_testing.TextUIFactory(u"") as factory:
 
128
            factory.choose(u"prompt", u"&yes\n&No\nmore &info")
 
129
            self.assertEqual(
 
130
                "prompt ([y]es, [N]o, more [i]nfo): \n",
 
131
                factory.stderr.getvalue())
 
132
 
 
133
    def test_text_ui_choose_prompt_automatic(self):
161
134
        # automatic shortcuts
162
 
        factory.stderr.truncate(0)
163
 
        factory.choose(u"prompt", u"yes\nNo\nmore info")
164
 
        self.assertEqual("prompt ([y]es, [N]o, [m]ore info): \n", factory.stderr.getvalue())
 
135
        with ui_testing.TextUIFactory(u"") as factory:
 
136
            factory.choose(u"prompt", u"yes\nNo\nmore info")
 
137
            self.assertEqual(
 
138
                "prompt ([y]es, [N]o, [m]ore info): \n",
 
139
                factory.stderr.getvalue())
165
140
 
166
141
    def test_text_ui_choose_return_values(self):
167
 
        choose = lambda: factory.choose(u"", u"&Yes\n&No\nMaybe\nmore &info", 3)
168
 
        stdin = tests.StringIOWrapper("y\n" # 0
169
 
                                      "n\n" # 1
170
 
                                      " \n" # default: 3
171
 
                                      " no \n" # 1
172
 
                                      "b\na\nd \n" # bad shortcuts, all ignored
173
 
                                      "yes with garbage\nY\n" # 0
174
 
                                      "not an answer\nno\n" # 1
175
 
                                      "info\nmore info\n" # 3
176
 
                                      "Maybe\n" # 2
177
 
                                      "foo\n")
178
 
        stdout = tests.StringIOWrapper()
179
 
        stderr = tests.StringIOWrapper()
180
 
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
181
 
        self.assertEqual(0, choose())
182
 
        self.assertEqual(1, choose())
183
 
        self.assertEqual(3, choose())
184
 
        self.assertEqual(1, choose())
185
 
        self.assertEqual(0, choose())
186
 
        self.assertEqual(1, choose())
187
 
        self.assertEqual(3, choose())
188
 
        self.assertEqual(2, choose())
189
 
        self.assertEqual("foo\n", factory.stdin.read())
190
 
        # stdin should be empty
191
 
        self.assertEqual('', factory.stdin.readline())
192
 
        # return None on EOF
193
 
        self.assertEqual(None, choose())
 
142
        def choose():
 
143
            return factory.choose(u"", u"&Yes\n&No\nMaybe\nmore &info", 3)
 
144
        stdin_text = (
 
145
            "y\n"  # 0
 
146
            "n\n"  # 1
 
147
            " \n"  # default: 3
 
148
            " no \n"  # 1
 
149
            "b\na\nd \n"  # bad shortcuts, all ignored
 
150
            "yes with garbage\nY\n"  # 0
 
151
            "not an answer\nno\n"  # 1
 
152
            "info\nmore info\n"  # 3
 
153
            "Maybe\n"  # 2
 
154
            "foo\n")
 
155
        with ui_testing.TextUIFactory(stdin_text) as factory:
 
156
            self.assertEqual(0, choose())
 
157
            self.assertEqual(1, choose())
 
158
            self.assertEqual(3, choose())
 
159
            self.assertEqual(1, choose())
 
160
            self.assertEqual(0, choose())
 
161
            self.assertEqual(1, choose())
 
162
            self.assertEqual(3, choose())
 
163
            self.assertEqual(2, choose())
 
164
            self.assertEqual("foo\n", factory.stdin.read())
 
165
            # stdin should be empty
 
166
            self.assertEqual('', factory.stdin.readline())
 
167
            # return None on EOF
 
168
            self.assertEqual(None, choose())
194
169
 
195
170
    def test_text_ui_choose_no_default(self):
196
 
        stdin = tests.StringIOWrapper(" \n" # no default, invalid!
197
 
                                      " yes \n" # 0
198
 
                                      "foo\n")
199
 
        stdout = tests.StringIOWrapper()
200
 
        stderr = tests.StringIOWrapper()
201
 
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
202
 
        self.assertEqual(0, factory.choose(u"", u"&Yes\n&No"))
203
 
        self.assertEqual("foo\n", factory.stdin.read())
 
171
        stdin_text = (
 
172
            " \n"  # no default, invalid!
 
173
            " yes \n"  # 0
 
174
            "foo\n")
 
175
        with ui_testing.TextUIFactory(stdin_text) as factory:
 
176
            self.assertEqual(0, factory.choose(u"", u"&Yes\n&No"))
 
177
            self.assertEqual("foo\n", factory.stdin.read())
204
178
 
205
179
    def test_text_ui_get_integer(self):
206
 
        stdin = tests.StringIOWrapper(
 
180
        stdin_text = (
207
181
            "1\n"
208
182
            "  -2  \n"
209
183
            "hmmm\nwhat else ?\nCome on\nok 42\n4.24\n42\n")
210
 
        stdout = tests.StringIOWrapper()
211
 
        stderr = tests.StringIOWrapper()
212
 
        factory = _mod_ui_text.TextUIFactory(stdin, stdout, stderr)
213
 
        self.assertEqual(1, factory.get_integer(u""))
214
 
        self.assertEqual(-2, factory.get_integer(u""))
215
 
        self.assertEqual(42, factory.get_integer(u""))
 
184
        with ui_testing.TextUIFactory(stdin_text) as factory:
 
185
            self.assertEqual(1, factory.get_integer(u""))
 
186
            self.assertEqual(-2, factory.get_integer(u""))
 
187
            self.assertEqual(42, factory.get_integer(u""))
216
188
 
217
189
    def test_text_factory_prompt(self):
218
190
        # see <https://launchpad.net/bugs/365891>
219
 
        StringIO = tests.StringIOWrapper
220
 
        factory = _mod_ui_text.TextUIFactory(StringIO(), StringIO(), StringIO())
221
 
        factory.prompt(u'foo %2e')
222
 
        self.assertEqual('', factory.stdout.getvalue())
223
 
        self.assertEqual('foo %2e', factory.stderr.getvalue())
 
191
        with ui_testing.TextUIFactory() as factory:
 
192
            factory.prompt(u'foo %2e')
 
193
            self.assertEqual('', factory.stdout.getvalue())
 
194
            self.assertEqual('foo %2e', factory.stderr.getvalue())
224
195
 
225
196
    def test_text_factory_prompts_and_clears(self):
226
197
        # a get_boolean call should clear the pb before prompting
227
 
        out = TTYStringIO()
 
198
        out = ui_testing.StringIOAsTTY()
228
199
        self.overrideEnv('TERM', 'xterm')
229
 
        factory = _mod_ui_text.TextUIFactory(
230
 
            stdin=tests.StringIOWrapper("yada\ny\n"),
231
 
            stdout=out, stderr=out)
232
 
        factory._avail_width = lambda: 79
233
 
        pb = factory.nested_progress_bar()
234
 
        pb.show_bar = False
235
 
        pb.show_spinner = False
236
 
        pb.show_count = False
237
 
        pb.update("foo", 0, 1)
238
 
        self.assertEqual(True,
239
 
                         self.apply_redirected(None, factory.stdout,
240
 
                                               factory.stdout,
241
 
                                               factory.get_boolean,
242
 
                                               u"what do you want"))
243
 
        output = out.getvalue()
244
 
        self.assertContainsRe(output,
245
 
            "| foo *\r\r  *\r*")
246
 
        self.assertContainsString(output,
247
 
            r"what do you want? ([y]es, [n]o): what do you want? ([y]es, [n]o): ")
248
 
        # stdin should have been totally consumed
249
 
        self.assertEqual('', factory.stdin.readline())
 
200
        factory = ui_testing.TextUIFactory("yada\ny\n", stdout=out, stderr=out)
 
201
        with factory:
 
202
            pb = factory.nested_progress_bar()
 
203
            pb._avail_width = lambda: 79
 
204
            pb.show_bar = False
 
205
            pb.show_spinner = False
 
206
            pb.show_count = False
 
207
            pb.update("foo", 0, 1)
 
208
            self.assertEqual(
 
209
                True,
 
210
                self.apply_redirected(
 
211
                    None, factory.stdout, factory.stdout, factory.get_boolean,
 
212
                    u"what do you want"))
 
213
            output = out.getvalue()
 
214
            self.assertContainsRe(output,
 
215
                                  "| foo *\r\r  *\r*")
 
216
            self.assertContainsString(
 
217
                output,
 
218
                r"what do you want? ([y]es, [n]o): what do you want? "
 
219
                r"([y]es, [n]o): ")
 
220
            # stdin should have been totally consumed
 
221
            self.assertEqual('', factory.stdin.readline())
250
222
 
251
223
    def test_text_tick_after_update(self):
252
 
        ui_factory = _mod_ui_text.TextUIFactory(stdout=tests.StringIOWrapper(),
253
 
                                                stderr=tests.StringIOWrapper())
254
 
        pb = ui_factory.nested_progress_bar()
255
 
        try:
 
224
        ui_factory = ui_testing.TextUIFactory()
 
225
        with ui_factory.nested_progress_bar() as pb:
256
226
            pb.update('task', 0, 3)
257
227
            # Reset the clock, so that it actually tries to repaint itself
258
228
            ui_factory._progress_view._last_repaint = time.time() - 1.0
259
229
            pb.tick()
260
 
        finally:
261
 
            pb.finished()
262
230
 
263
231
    def test_text_ui_getusername(self):
264
 
        ui = _mod_ui_text.TextUIFactory(None, None, None)
265
 
        ui.stdin = tests.StringIOWrapper('someuser\n\n')
266
 
        ui.stdout = tests.StringIOWrapper()
267
 
        ui.stderr = tests.StringIOWrapper()
268
 
        ui.stdout.encoding = 'utf8'
 
232
        ui = ui_testing.TextUIFactory('someuser\n\n')
269
233
        self.assertEqual('someuser',
270
234
                         ui.get_username(u'Hello %(host)s', host='some'))
271
 
        self.assertEquals('Hello some: ', ui.stderr.getvalue())
272
 
        self.assertEquals('', ui.stdout.getvalue())
 
235
        self.assertEqual('Hello some: ', ui.stderr.getvalue())
 
236
        self.assertEqual('', ui.stdout.getvalue())
273
237
        self.assertEqual('', ui.get_username(u"Gebruiker"))
274
238
        # stdin should be empty
275
239
        self.assertEqual('', ui.stdin.readline())
276
240
 
277
 
    def test_text_ui_getusername_utf8(self):
278
 
        ui = _mod_ui_text.TextUIFactory(None, None, None)
279
 
        ui.stdin = tests.StringIOWrapper(u'someuser\u1234'.encode('utf8'))
280
 
        ui.stdout = tests.StringIOWrapper()
281
 
        ui.stderr = tests.StringIOWrapper()
282
 
        ui.stderr.encoding = ui.stdout.encoding = ui.stdin.encoding = "utf8"
 
241
    def test_text_ui_getusername_unicode(self):
 
242
        ui = ui_testing.TextUIFactory(u'someuser\u1234')
283
243
        username = ui.get_username(u'Hello %(host)s', host=u'some\u1234')
284
 
        self.assertEquals(u"someuser\u1234", username)
285
 
        self.assertEquals(u"Hello some\u1234: ",
286
 
                          ui.stderr.getvalue().decode("utf8"))
287
 
        self.assertEquals('', ui.stdout.getvalue())
 
244
        self.assertEqual(u"someuser\u1234", username)
 
245
        self.assertEqual(u"Hello some\u1234: ", ui.stderr.getvalue())
 
246
        self.assertEqual('', ui.stdout.getvalue())
288
247
 
289
248
    def test_quietness(self):
290
 
        self.overrideEnv('BZR_PROGRESS_BAR', 'text')
291
 
        ui_factory = _mod_ui_text.TextUIFactory(None,
292
 
            TTYStringIO(),
293
 
            TTYStringIO())
294
 
        self.assertIsInstance(ui_factory._progress_view,
295
 
            _mod_ui_text.TextProgressView)
296
 
        ui_factory.be_quiet(True)
297
 
        self.assertIsInstance(ui_factory._progress_view,
298
 
            _mod_ui_text.NullProgressView)
 
249
        self.overrideEnv('BRZ_PROGRESS_BAR', 'text')
 
250
        ui_factory = ui_testing.TextUIFactory(
 
251
            stderr=ui_testing.StringIOAsTTY())
 
252
        with ui_factory:
 
253
            self.assertIsInstance(ui_factory._progress_view,
 
254
                                  _mod_ui_text.TextProgressView)
 
255
            ui_factory.be_quiet(True)
 
256
            self.assertIsInstance(ui_factory._progress_view,
 
257
                                  _mod_ui_text.NullProgressView)
299
258
 
300
259
    def test_text_ui_show_user_warning(self):
301
 
        from bzrlib.repofmt.groupcompress_repo import RepositoryFormat2a
302
 
        from bzrlib.repofmt.knitpack_repo import RepositoryFormatKnitPack5
303
 
        err = StringIO()
304
 
        out = StringIO()
305
 
        ui = tests.TextUIFactory(stdin=None, stdout=out, stderr=err)
 
260
        from ..bzr.groupcompress_repo import RepositoryFormat2a
 
261
        from ..bzr.knitpack_repo import RepositoryFormatKnitPack5
 
262
        ui = ui_testing.TextUIFactory()
306
263
        remote_fmt = remote.RemoteRepositoryFormat()
307
264
        remote_fmt._network_name = RepositoryFormatKnitPack5().network_name()
308
 
        ui.show_user_warning('cross_format_fetch', from_format=RepositoryFormat2a(),
 
265
        ui.show_user_warning(
 
266
            'cross_format_fetch', from_format=RepositoryFormat2a(),
309
267
            to_format=remote_fmt)
310
 
        self.assertEquals('', out.getvalue())
311
 
        self.assertEquals("Doing on-the-fly conversion from RepositoryFormat2a() to "
312
 
            "RemoteRepositoryFormat(_network_name='Bazaar RepositoryFormatKnitPack5 "
313
 
            "(bzr 1.6)\\n').\nThis may take some time. Upgrade the repositories to "
314
 
            "the same format for better performance.\n",
315
 
            err.getvalue())
 
268
        self.assertEqual('', ui.stdout.getvalue())
 
269
        self.assertContainsRe(
 
270
            ui.stderr.getvalue(),
 
271
            "^Doing on-the-fly conversion from RepositoryFormat2a\\(\\) to "
 
272
            "RemoteRepositoryFormat\\(_network_name="
 
273
            "b?'Bazaar RepositoryFormatKnitPack5 \\(bzr 1.6\\)\\\\n'\\)\\.\n"
 
274
            "This may take some time. Upgrade the repositories to "
 
275
            "the same format for better performance\\.\n$")
316
276
        # and now with it suppressed please
317
 
        err = StringIO()
318
 
        out = StringIO()
319
 
        ui = tests.TextUIFactory(stdin=None, stdout=out, stderr=err)
 
277
        ui = ui_testing.TextUIFactory()
320
278
        ui.suppressed_warnings.add('cross_format_fetch')
321
 
        ui.show_user_warning('cross_format_fetch', from_format=RepositoryFormat2a(),
 
279
        ui.show_user_warning(
 
280
            'cross_format_fetch', from_format=RepositoryFormat2a(),
322
281
            to_format=remote_fmt)
323
 
        self.assertEquals('', out.getvalue())
324
 
        self.assertEquals('', err.getvalue())
 
282
        self.assertEqual('', ui.stdout.getvalue())
 
283
        self.assertEqual('', ui.stderr.getvalue())
325
284
 
326
285
 
327
286
class TestTextUIOutputStream(tests.TestCase):
328
287
    """Tests for output stream that synchronizes with progress bar."""
329
288
 
330
289
    def test_output_clears_terminal(self):
331
 
        stdout = tests.StringIOWrapper()
332
 
        stderr = tests.StringIOWrapper()
333
290
        clear_calls = []
334
291
 
335
 
        uif =  _mod_ui_text.TextUIFactory(None, stdout, stderr)
 
292
        uif = ui_testing.TextUIFactory()
336
293
        uif.clear_term = lambda: clear_calls.append('clear')
337
294
 
338
 
        stream = _mod_ui_text.TextUIOutputStream(uif, uif.stdout)
339
 
        stream.write("Hello world!\n")
340
 
        stream.write("there's more...\n")
341
 
        stream.writelines(["1\n", "2\n", "3\n"])
 
295
        stream = _mod_ui_text.TextUIOutputStream(
 
296
            uif, uif.stdout, 'utf-8', 'strict')
 
297
        stream.write(u"Hello world!\n")
 
298
        stream.write(u"there's more...\n")
 
299
        stream.writelines([u"1\n", u"2\n", u"3\n"])
342
300
 
343
 
        self.assertEqual(stdout.getvalue(),
344
 
            "Hello world!\n"
345
 
            "there's more...\n"
346
 
            "1\n2\n3\n")
 
301
        self.assertEqual(uif.stdout.getvalue(),
 
302
                         u"Hello world!\n"
 
303
                         u"there's more...\n"
 
304
                         u"1\n2\n3\n")
347
305
        self.assertEqual(['clear', 'clear', 'clear'],
348
 
            clear_calls)
 
306
                         clear_calls)
349
307
 
350
308
        stream.flush()
351
309
 
355
313
    def test_progress_construction(self):
356
314
        """TextUIFactory constructs the right progress view.
357
315
        """
358
 
        FileStringIO = tests.StringIOWrapper
 
316
        FileStringIO = ui_testing.StringIOWithEncoding
 
317
        TTYStringIO = ui_testing.StringIOAsTTY
359
318
        for (file_class, term, pb, expected_pb_class) in (
360
 
            # on an xterm, either use them or not as the user requests,
361
 
            # otherwise default on
362
 
            (TTYStringIO, 'xterm', 'none', _mod_ui_text.NullProgressView),
363
 
            (TTYStringIO, 'xterm', 'text', _mod_ui_text.TextProgressView),
364
 
            (TTYStringIO, 'xterm', None, _mod_ui_text.TextProgressView),
365
 
            # on a dumb terminal, again if there's explicit configuration do
366
 
            # it, otherwise default off
367
 
            (TTYStringIO, 'dumb', 'none', _mod_ui_text.NullProgressView),
368
 
            (TTYStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),
369
 
            (TTYStringIO, 'dumb', None, _mod_ui_text.NullProgressView),
370
 
            # on a non-tty terminal, it's null regardless of $TERM
371
 
            (FileStringIO, 'xterm', None, _mod_ui_text.NullProgressView),
372
 
            (FileStringIO, 'dumb', None, _mod_ui_text.NullProgressView),
373
 
            # however, it can still be forced on
374
 
            (FileStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),
375
 
            ):
 
319
                # on an xterm, either use them or not as the user requests,
 
320
                # otherwise default on
 
321
                (TTYStringIO, 'xterm', 'none', _mod_ui_text.NullProgressView),
 
322
                (TTYStringIO, 'xterm', 'text', _mod_ui_text.TextProgressView),
 
323
                (TTYStringIO, 'xterm', None, _mod_ui_text.TextProgressView),
 
324
                # on a dumb terminal, again if there's explicit configuration
 
325
                # do it, otherwise default off
 
326
                (TTYStringIO, 'dumb', 'none', _mod_ui_text.NullProgressView),
 
327
                (TTYStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),
 
328
                (TTYStringIO, 'dumb', None, _mod_ui_text.NullProgressView),
 
329
                # on a non-tty terminal, it's null regardless of $TERM
 
330
                (FileStringIO, 'xterm', None, _mod_ui_text.NullProgressView),
 
331
                (FileStringIO, 'dumb', None, _mod_ui_text.NullProgressView),
 
332
                # however, it can still be forced on
 
333
                (FileStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),
 
334
                ):
376
335
            self.overrideEnv('TERM', term)
377
 
            self.overrideEnv('BZR_PROGRESS_BAR', pb)
378
 
            stdin = file_class('')
 
336
            self.overrideEnv('BRZ_PROGRESS_BAR', pb)
 
337
            stdin = file_class(u'')
379
338
            stderr = file_class()
380
339
            stdout = file_class()
381
340
            uif = _mod_ui.make_ui_for_terminal(stdin, stdout, stderr)
382
 
            self.assertIsInstance(uif, _mod_ui_text.TextUIFactory,
383
 
                "TERM=%s BZR_PROGRESS_BAR=%s uif=%r" % (term, pb, uif,))
384
 
            self.assertIsInstance(uif.make_progress_view(),
 
341
            self.assertIsInstance(
 
342
                uif, _mod_ui_text.TextUIFactory,
 
343
                "TERM=%s BRZ_PROGRESS_BAR=%s uif=%r" % (term, pb, uif,))
 
344
            self.assertIsInstance(
 
345
                uif.make_progress_view(),
385
346
                expected_pb_class,
386
 
                "TERM=%s BZR_PROGRESS_BAR=%s uif=%r" % (term, pb, uif,))
 
347
                "TERM=%s BRZ_PROGRESS_BAR=%s uif=%r" % (term, pb, uif,))
387
348
 
388
349
    def test_text_ui_non_terminal(self):
389
350
        """Even on non-ttys, make_ui_for_terminal gives a text ui."""
390
 
        stdin = NonTTYStringIO('')
391
 
        stderr = NonTTYStringIO()
392
 
        stdout = NonTTYStringIO()
 
351
        stdin = stderr = stdout = ui_testing.StringIOWithEncoding()
393
352
        for term_type in ['dumb', None, 'xterm']:
394
353
            self.overrideEnv('TERM', term_type)
395
354
            uif = _mod_ui.make_ui_for_terminal(stdin, stdout, stderr)
396
355
            self.assertIsInstance(uif, _mod_ui_text.TextUIFactory,
397
 
                'TERM=%r' % (term_type,))
 
356
                                  'TERM=%r' % (term_type,))
398
357
 
399
358
 
400
359
class SilentUITests(tests.TestCase):
404
363
        # password.  Possibly it should raise a more specific error but it
405
364
        # can't succeed.
406
365
        ui = _mod_ui.SilentUIFactory()
407
 
        stdout = tests.StringIOWrapper()
 
366
        stdout = ui_testing.StringIOWithEncoding()
408
367
        self.assertRaises(
409
368
            NotImplementedError,
410
369
            self.apply_redirected,
414
373
 
415
374
    def test_silent_ui_getbool(self):
416
375
        factory = _mod_ui.SilentUIFactory()
417
 
        stdout = tests.StringIOWrapper()
 
376
        stdout = ui_testing.StringIOWithEncoding()
418
377
        self.assertRaises(
419
378
            NotImplementedError,
420
379
            self.apply_redirected,
426
385
    def test_test_ui_factory_progress(self):
427
386
        # there's no output; we just want to make sure this doesn't crash -
428
387
        # see https://bugs.launchpad.net/bzr/+bug/408201
429
 
        ui = tests.TestUIFactory()
430
 
        pb = ui.nested_progress_bar()
431
 
        pb.update('hello')
432
 
        pb.tick()
433
 
        pb.finished()
 
388
        ui = ui_testing.TestUIFactory()
 
389
        with ui.nested_progress_bar() as pb:
 
390
            pb.update('hello')
 
391
            pb.tick()
434
392
 
435
393
 
436
394
class CannedInputUIFactoryTests(tests.TestCase):
449
407
 
450
408
    def assertIsTrue(self, s, accepted_values=None):
451
409
        res = _mod_ui.bool_from_string(s, accepted_values=accepted_values)
452
 
        self.assertEquals(True, res)
 
410
        self.assertEqual(True, res)
453
411
 
454
412
    def assertIsFalse(self, s, accepted_values=None):
455
413
        res = _mod_ui.bool_from_string(s, accepted_values=accepted_values)
456
 
        self.assertEquals(False, res)
 
414
        self.assertEqual(False, res)
457
415
 
458
416
    def assertIsNone(self, s, accepted_values=None):
459
417
        res = _mod_ui.bool_from_string(s, accepted_values=accepted_values)
506
464
    def test_confirm_action_default(self):
507
465
        base_ui = _mod_ui.NoninteractiveUIFactory()
508
466
        for answer in [True, False]:
509
 
            self.assertEquals(
 
467
            self.assertEqual(
510
468
                _mod_ui.ConfirmationUserInterfacePolicy(base_ui, answer, {})
511
469
                .confirm_action("Do something?",
512
 
                    "bzrlib.tests.do_something", {}),
 
470
                                "breezy.tests.do_something", {}),
513
471
                answer)
514
472
 
515
473
    def test_confirm_action_specific(self):
518
476
            for specific_answer in [True, False]:
519
477
                for conf_id in ['given_id', 'other_id']:
520
478
                    wrapper = _mod_ui.ConfirmationUserInterfacePolicy(
521
 
                        base_ui, default_answer, dict(given_id=specific_answer))
522
 
                    result = wrapper.confirm_action("Do something?", conf_id, {})
 
479
                        base_ui, default_answer,
 
480
                        dict(given_id=specific_answer))
 
481
                    result = wrapper.confirm_action(
 
482
                        "Do something?", conf_id, {})
523
483
                    if conf_id == 'given_id':
524
 
                        self.assertEquals(result, specific_answer)
 
484
                        self.assertEqual(result, specific_answer)
525
485
                    else:
526
 
                        self.assertEquals(result, default_answer)
 
486
                        self.assertEqual(result, default_answer)
527
487
 
528
488
    def test_repr(self):
529
489
        base_ui = _mod_ui.NoninteractiveUIFactory()
530
490
        wrapper = _mod_ui.ConfirmationUserInterfacePolicy(
531
491
            base_ui, True, dict(a=2))
532
492
        self.assertThat(repr(wrapper),
533
 
            Equals("ConfirmationUserInterfacePolicy("
534
 
                "NoninteractiveUIFactory(), True, {'a': 2})"))
 
493
                        Equals("ConfirmationUserInterfacePolicy("
 
494
                               "NoninteractiveUIFactory(), True, {'a': 2})"))
535
495
 
536
496
 
537
497
class TestProgressRecordingUI(tests.TestCase):