/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: Jelmer Vernooij
  • Date: 2018-02-18 21:42:57 UTC
  • mto: This revision was merged to the branch mainline in revision 6859.
  • Revision ID: jelmer@jelmer.uk-20180218214257-jpevutp1wa30tz3v
Update TODO to reference Breezy, not Bazaar.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_ui.py
53
53
 
54
54
    def test_text_factory_confirm(self):
55
55
        # turns into reading a regular boolean
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'}))
 
56
        ui = ui_testing.TestUIFactory('n\n')
 
57
        self.assertEqual(ui.confirm_action(u'Should %(thing)s pass?',
 
58
            'breezy.tests.test_ui.confirmation',
 
59
            {'thing': 'this'},),
 
60
            False)
63
61
 
64
62
    def test_text_factory_ascii_password(self):
65
63
        ui = ui_testing.TestUIFactory('secret\n')
66
 
        with ui.nested_progress_bar():
 
64
        pb = ui.nested_progress_bar()
 
65
        try:
67
66
            self.assertEqual('secret',
68
67
                             self.apply_redirected(ui.stdin, ui.stdout,
69
68
                                                   ui.stderr,
73
72
            self.assertEqual('', ui.stdout.readline())
74
73
            # stdin should be empty
75
74
            self.assertEqual('', ui.stdin.readline())
 
75
        finally:
 
76
            pb.finished()
76
77
 
77
78
    def test_text_factory_unicode_password(self):
78
79
        """Test a unicode password."""
79
80
        ui = ui_testing.TextUIFactory(u'baz\u1234')
80
 
        password = ui.get_password(
81
 
            u'Hello \u1234 %(user)s', user=u'some\u1234')
 
81
        password = ui.get_password(u'Hello \u1234 %(user)s', user=u'some\u1234')
82
82
        self.assertEqual(u'baz\u1234', password)
83
83
        self.assertEqual(u'Hello \u1234 some\u1234: ', ui.stderr.getvalue())
84
84
        # stdin and stdout should be empty
87
87
 
88
88
    def test_text_ui_get_boolean(self):
89
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
 
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
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""))
 
99
        factory = ui_testing.TextUIFactory(stdin_text)
 
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""))
113
113
 
114
114
    def test_text_ui_choose_bad_parameters(self):
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")
 
115
        factory = ui_testing.TextUIFactory(u"")
 
116
        # invalid default index
 
117
        self.assertRaises(ValueError, factory.choose, u"", u"&Yes\n&No", 3)
 
118
        # duplicated choice
 
119
        self.assertRaises(ValueError, factory.choose, u"", u"&choice\n&ChOiCe")
 
120
        # duplicated shortcut
 
121
        self.assertRaises(ValueError, factory.choose, u"", u"&choice1\nchoi&ce2")
124
122
 
125
123
    def test_text_ui_choose_prompt_explicit(self):
126
124
        # choices with explicit shortcuts
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())
 
125
        factory = ui_testing.TextUIFactory(u"")
 
126
        factory.choose(u"prompt", u"&yes\n&No\nmore &info")
 
127
        self.assertEqual("prompt ([y]es, [N]o, more [i]nfo): \n", factory.stderr.getvalue())
132
128
 
133
129
    def test_text_ui_choose_prompt_automatic(self):
134
130
        # automatic shortcuts
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())
 
131
        factory = ui_testing.TextUIFactory(u"")
 
132
        factory.choose(u"prompt", u"yes\nNo\nmore info")
 
133
        self.assertEqual("prompt ([y]es, [N]o, [m]ore info): \n", factory.stderr.getvalue())
140
134
 
141
135
    def test_text_ui_choose_return_values(self):
142
 
        def choose():
143
 
            return factory.choose(u"", u"&Yes\n&No\nMaybe\nmore &info", 3)
 
136
        choose = lambda: factory.choose(u"", u"&Yes\n&No\nMaybe\nmore &info", 3)
144
137
        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
 
138
            "y\n" # 0
 
139
            "n\n" # 1
 
140
            " \n" # default: 3
 
141
            " no \n" # 1
 
142
            "b\na\nd \n" # bad shortcuts, all ignored
 
143
            "yes with garbage\nY\n" # 0
 
144
            "not an answer\nno\n" # 1
 
145
            "info\nmore info\n" # 3
 
146
            "Maybe\n" # 2
154
147
            "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())
 
148
        factory = ui_testing.TextUIFactory(stdin_text)
 
149
        self.assertEqual(0, choose())
 
150
        self.assertEqual(1, choose())
 
151
        self.assertEqual(3, choose())
 
152
        self.assertEqual(1, choose())
 
153
        self.assertEqual(0, choose())
 
154
        self.assertEqual(1, choose())
 
155
        self.assertEqual(3, choose())
 
156
        self.assertEqual(2, choose())
 
157
        self.assertEqual("foo\n", factory.stdin.read())
 
158
        # stdin should be empty
 
159
        self.assertEqual('', factory.stdin.readline())
 
160
        # return None on EOF
 
161
        self.assertEqual(None, choose())
169
162
 
170
163
    def test_text_ui_choose_no_default(self):
171
164
        stdin_text = (
172
 
            " \n"  # no default, invalid!
173
 
            " yes \n"  # 0
 
165
            " \n" # no default, invalid!
 
166
            " yes \n" # 0
174
167
            "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())
 
168
        factory = ui_testing.TextUIFactory(stdin_text)
 
169
        self.assertEqual(0, factory.choose(u"", u"&Yes\n&No"))
 
170
        self.assertEqual("foo\n", factory.stdin.read())
178
171
 
179
172
    def test_text_ui_get_integer(self):
180
173
        stdin_text = (
181
174
            "1\n"
182
175
            "  -2  \n"
183
176
            "hmmm\nwhat else ?\nCome on\nok 42\n4.24\n42\n")
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""))
 
177
        factory = ui_testing.TextUIFactory(stdin_text)
 
178
        self.assertEqual(1, factory.get_integer(u""))
 
179
        self.assertEqual(-2, factory.get_integer(u""))
 
180
        self.assertEqual(42, factory.get_integer(u""))
188
181
 
189
182
    def test_text_factory_prompt(self):
190
183
        # see <https://launchpad.net/bugs/365891>
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())
 
184
        factory = ui_testing.TextUIFactory()
 
185
        factory.prompt(u'foo %2e')
 
186
        self.assertEqual('', factory.stdout.getvalue())
 
187
        self.assertEqual('foo %2e', factory.stderr.getvalue())
195
188
 
196
189
    def test_text_factory_prompts_and_clears(self):
197
190
        # a get_boolean call should clear the pb before prompting
198
191
        out = ui_testing.StringIOAsTTY()
199
192
        self.overrideEnv('TERM', 'xterm')
200
193
        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())
 
194
        pb = factory.nested_progress_bar()
 
195
        pb._avail_width = lambda: 79
 
196
        pb.show_bar = False
 
197
        pb.show_spinner = False
 
198
        pb.show_count = False
 
199
        pb.update("foo", 0, 1)
 
200
        self.assertEqual(True,
 
201
                         self.apply_redirected(None, factory.stdout,
 
202
                                               factory.stdout,
 
203
                                               factory.get_boolean,
 
204
                                               u"what do you want"))
 
205
        output = out.getvalue()
 
206
        self.assertContainsRe(output,
 
207
            "| foo *\r\r  *\r*")
 
208
        self.assertContainsString(output,
 
209
            r"what do you want? ([y]es, [n]o): what do you want? ([y]es, [n]o): ")
 
210
        # stdin should have been totally consumed
 
211
        self.assertEqual('', factory.stdin.readline())
222
212
 
223
213
    def test_text_tick_after_update(self):
224
214
        ui_factory = ui_testing.TextUIFactory()
225
 
        with ui_factory.nested_progress_bar() as pb:
 
215
        pb = ui_factory.nested_progress_bar()
 
216
        try:
226
217
            pb.update('task', 0, 3)
227
218
            # Reset the clock, so that it actually tries to repaint itself
228
219
            ui_factory._progress_view._last_repaint = time.time() - 1.0
229
220
            pb.tick()
 
221
        finally:
 
222
            pb.finished()
230
223
 
231
224
    def test_text_ui_getusername(self):
232
225
        ui = ui_testing.TextUIFactory('someuser\n\n')
249
242
        self.overrideEnv('BRZ_PROGRESS_BAR', 'text')
250
243
        ui_factory = ui_testing.TextUIFactory(
251
244
            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)
 
245
        self.assertIsInstance(ui_factory._progress_view,
 
246
            _mod_ui_text.TextProgressView)
 
247
        ui_factory.be_quiet(True)
 
248
        self.assertIsInstance(ui_factory._progress_view,
 
249
            _mod_ui_text.NullProgressView)
258
250
 
259
251
    def test_text_ui_show_user_warning(self):
260
252
        from ..bzr.groupcompress_repo import RepositoryFormat2a
262
254
        ui = ui_testing.TextUIFactory()
263
255
        remote_fmt = remote.RemoteRepositoryFormat()
264
256
        remote_fmt._network_name = RepositoryFormatKnitPack5().network_name()
265
 
        ui.show_user_warning(
266
 
            'cross_format_fetch', from_format=RepositoryFormat2a(),
 
257
        ui.show_user_warning('cross_format_fetch', from_format=RepositoryFormat2a(),
267
258
            to_format=remote_fmt)
268
259
        self.assertEqual('', ui.stdout.getvalue())
269
260
        self.assertContainsRe(
270
261
            ui.stderr.getvalue(),
271
262
            "^Doing on-the-fly conversion from RepositoryFormat2a\\(\\) to "
272
 
            "RemoteRepositoryFormat\\(_network_name="
273
 
            "b?'Bazaar RepositoryFormatKnitPack5 \\(bzr 1.6\\)\\\\n'\\)\\.\n"
 
263
                "RemoteRepositoryFormat\\(_network_name="
 
264
                "b?'Bazaar RepositoryFormatKnitPack5 \\(bzr 1.6\\)\\\\n'\\)\\.\n"
274
265
            "This may take some time. Upgrade the repositories to "
275
 
            "the same format for better performance\\.\n$")
 
266
                "the same format for better performance\\.\n$")
276
267
        # and now with it suppressed please
277
268
        ui = ui_testing.TextUIFactory()
278
269
        ui.suppressed_warnings.add('cross_format_fetch')
279
 
        ui.show_user_warning(
280
 
            'cross_format_fetch', from_format=RepositoryFormat2a(),
 
270
        ui.show_user_warning('cross_format_fetch', from_format=RepositoryFormat2a(),
281
271
            to_format=remote_fmt)
282
272
        self.assertEqual('', ui.stdout.getvalue())
283
273
        self.assertEqual('', ui.stderr.getvalue())
289
279
    def test_output_clears_terminal(self):
290
280
        clear_calls = []
291
281
 
292
 
        uif = ui_testing.TextUIFactory()
 
282
        uif =  ui_testing.TextUIFactory()
293
283
        uif.clear_term = lambda: clear_calls.append('clear')
294
284
 
295
 
        stream = _mod_ui_text.TextUIOutputStream(
296
 
            uif, uif.stdout, 'utf-8', 'strict')
 
285
        stream = _mod_ui_text.TextUIOutputStream(uif, uif.stdout, 'utf-8', 'strict')
297
286
        stream.write(u"Hello world!\n")
298
287
        stream.write(u"there's more...\n")
299
288
        stream.writelines([u"1\n", u"2\n", u"3\n"])
300
289
 
301
290
        self.assertEqual(uif.stdout.getvalue(),
302
 
                         u"Hello world!\n"
303
 
                         u"there's more...\n"
304
 
                         u"1\n2\n3\n")
 
291
            u"Hello world!\n"
 
292
            u"there's more...\n"
 
293
            u"1\n2\n3\n")
305
294
        self.assertEqual(['clear', 'clear', 'clear'],
306
 
                         clear_calls)
 
295
            clear_calls)
307
296
 
308
297
        stream.flush()
309
298
 
316
305
        FileStringIO = ui_testing.StringIOWithEncoding
317
306
        TTYStringIO = ui_testing.StringIOAsTTY
318
307
        for (file_class, term, pb, expected_pb_class) in (
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
 
                ):
 
308
            # on an xterm, either use them or not as the user requests,
 
309
            # otherwise default on
 
310
            (TTYStringIO, 'xterm', 'none', _mod_ui_text.NullProgressView),
 
311
            (TTYStringIO, 'xterm', 'text', _mod_ui_text.TextProgressView),
 
312
            (TTYStringIO, 'xterm', None, _mod_ui_text.TextProgressView),
 
313
            # on a dumb terminal, again if there's explicit configuration do
 
314
            # it, otherwise default off
 
315
            (TTYStringIO, 'dumb', 'none', _mod_ui_text.NullProgressView),
 
316
            (TTYStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),
 
317
            (TTYStringIO, 'dumb', None, _mod_ui_text.NullProgressView),
 
318
            # on a non-tty terminal, it's null regardless of $TERM
 
319
            (FileStringIO, 'xterm', None, _mod_ui_text.NullProgressView),
 
320
            (FileStringIO, 'dumb', None, _mod_ui_text.NullProgressView),
 
321
            # however, it can still be forced on
 
322
            (FileStringIO, 'dumb', 'text', _mod_ui_text.TextProgressView),
 
323
            ):
335
324
            self.overrideEnv('TERM', term)
336
325
            self.overrideEnv('BRZ_PROGRESS_BAR', pb)
337
326
            stdin = file_class(u'')
338
327
            stderr = file_class()
339
328
            stdout = file_class()
340
329
            uif = _mod_ui.make_ui_for_terminal(stdin, stdout, stderr)
341
 
            self.assertIsInstance(
342
 
                uif, _mod_ui_text.TextUIFactory,
 
330
            self.assertIsInstance(uif, _mod_ui_text.TextUIFactory,
343
331
                "TERM=%s BRZ_PROGRESS_BAR=%s uif=%r" % (term, pb, uif,))
344
 
            self.assertIsInstance(
345
 
                uif.make_progress_view(),
 
332
            self.assertIsInstance(uif.make_progress_view(),
346
333
                expected_pb_class,
347
334
                "TERM=%s BRZ_PROGRESS_BAR=%s uif=%r" % (term, pb, uif,))
348
335
 
353
340
            self.overrideEnv('TERM', term_type)
354
341
            uif = _mod_ui.make_ui_for_terminal(stdin, stdout, stderr)
355
342
            self.assertIsInstance(uif, _mod_ui_text.TextUIFactory,
356
 
                                  'TERM=%r' % (term_type,))
 
343
                'TERM=%r' % (term_type,))
357
344
 
358
345
 
359
346
class SilentUITests(tests.TestCase):
386
373
        # there's no output; we just want to make sure this doesn't crash -
387
374
        # see https://bugs.launchpad.net/bzr/+bug/408201
388
375
        ui = ui_testing.TestUIFactory()
389
 
        with ui.nested_progress_bar() as pb:
390
 
            pb.update('hello')
391
 
            pb.tick()
 
376
        pb = ui.nested_progress_bar()
 
377
        pb.update('hello')
 
378
        pb.tick()
 
379
        pb.finished()
392
380
 
393
381
 
394
382
class CannedInputUIFactoryTests(tests.TestCase):
467
455
            self.assertEqual(
468
456
                _mod_ui.ConfirmationUserInterfacePolicy(base_ui, answer, {})
469
457
                .confirm_action("Do something?",
470
 
                                "breezy.tests.do_something", {}),
 
458
                    "breezy.tests.do_something", {}),
471
459
                answer)
472
460
 
473
461
    def test_confirm_action_specific(self):
476
464
            for specific_answer in [True, False]:
477
465
                for conf_id in ['given_id', 'other_id']:
478
466
                    wrapper = _mod_ui.ConfirmationUserInterfacePolicy(
479
 
                        base_ui, default_answer,
480
 
                        dict(given_id=specific_answer))
481
 
                    result = wrapper.confirm_action(
482
 
                        "Do something?", conf_id, {})
 
467
                        base_ui, default_answer, dict(given_id=specific_answer))
 
468
                    result = wrapper.confirm_action("Do something?", conf_id, {})
483
469
                    if conf_id == 'given_id':
484
470
                        self.assertEqual(result, specific_answer)
485
471
                    else:
490
476
        wrapper = _mod_ui.ConfirmationUserInterfacePolicy(
491
477
            base_ui, True, dict(a=2))
492
478
        self.assertThat(repr(wrapper),
493
 
                        Equals("ConfirmationUserInterfacePolicy("
494
 
                               "NoninteractiveUIFactory(), True, {'a': 2})"))
 
479
            Equals("ConfirmationUserInterfacePolicy("
 
480
                "NoninteractiveUIFactory(), True, {'a': 2})"))
495
481
 
496
482
 
497
483
class TestProgressRecordingUI(tests.TestCase):