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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
from cStringIO import StringIO
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
from StringIO import StringIO
20
from bzrlib import errors
23
21
from bzrlib.progress import (
26
from bzrlib.ui.text import (
31
class TestTextProgressView(tests.TestCase):
32
"""Tests for text display of progress bars.
34
These try to exercise the progressview independently of its construction,
35
which is arranged by the TextUIFactory.
37
# The ProgressTask now connects directly to the ProgressView, so we can
38
# check them independently of the factory or of the determination of what
41
def make_view_only(self, out, width=79):
42
view = TextProgressView(out)
43
view._avail_width = lambda: width
48
return out, self.make_view_only(out)
50
def make_task(self, parent_task, view, msg, curr, total):
51
# would normally be done by UIFactory; is done here so that we don't
53
task = ProgressTask(parent_task, progress_view=view)
55
task.current_cnt = curr
56
task.total_cnt = total
22
DummyProgress, ChildProgress,
27
from bzrlib.tests import TestCase
31
def __init__(self, top):
37
class InstrumentedProgress(TTYProgressBar):
38
"""TTYProgress variant that tracks outcomes"""
40
def __init__(self, *args, **kwargs):
41
self.always_throttled = True
42
TTYProgressBar.__init__(self, *args, **kwargs)
44
def throttle(self, old_message):
45
result = TTYProgressBar.throttle(self, old_message)
47
self.always_throttled = False
50
class _TTYStringIO(StringIO):
51
"""A helper class which makes a StringIO look like a terminal"""
57
class _NonTTYStringIO(StringIO):
58
"""Helper that implements isatty() but returns False"""
64
class TestProgress(TestCase):
67
self.top = ChildProgress(_stack=FakeStack(q))
69
def test_propogation(self):
70
self.top.update('foobles', 1, 2)
71
self.assertEqual(self.top.message, 'foobles')
72
self.assertEqual(self.top.current, 1)
73
self.assertEqual(self.top.total, 2)
74
self.assertEqual(self.top.child_fraction, 0)
75
child = ChildProgress(_stack=FakeStack(self.top))
76
child.update('baubles', 2, 4)
77
self.assertEqual(self.top.message, 'foobles')
78
self.assertEqual(self.top.current, 1)
79
self.assertEqual(self.top.total, 2)
80
self.assertEqual(self.top.child_fraction, 0.5)
81
grandchild = ChildProgress(_stack=FakeStack(child))
82
grandchild.update('barbells', 1, 2)
83
self.assertEqual(self.top.child_fraction, 0.625)
84
self.assertEqual(child.child_fraction, 0.5)
85
child.update('baubles', 3, 4)
86
self.assertEqual(child.child_fraction, 0)
87
self.assertEqual(self.top.child_fraction, 0.75)
88
grandchild.update('barbells', 1, 2)
89
self.assertEqual(self.top.child_fraction, 0.875)
90
grandchild.update('barbells', 2, 2)
91
self.assertEqual(self.top.child_fraction, 1)
92
child.update('baubles', 4, 4)
93
self.assertEqual(self.top.child_fraction, 1)
95
grandchild.update('barbells', 2, 2)
96
self.assertEqual(self.top.child_fraction, 1)
98
def test_implementations(self):
99
for implementation in (TTYProgressBar, DotsProgressBar,
101
self.check_parent_handling(implementation)
103
def check_parent_handling(self, parentclass):
104
top = parentclass(to_file=StringIO())
105
top.update('foobles', 1, 2)
106
child = ChildProgress(_stack=FakeStack(top))
107
child.update('baubles', 4, 4)
108
top.update('lala', 2, 2)
109
child.update('baubles', 4, 4)
111
def test_stacking(self):
112
self.check_stack(TTYProgressBar, ChildProgress)
113
self.check_stack(DotsProgressBar, ChildProgress)
114
self.check_stack(DummyProgress, DummyProgress)
116
def check_stack(self, parent_class, child_class):
117
stack = ProgressBarStack(klass=parent_class, to_file=StringIO())
118
parent = stack.get_nested()
120
self.assertIs(parent.__class__, parent_class)
121
child = stack.get_nested()
123
self.assertIs(child.__class__, child_class)
129
def test_throttling(self):
130
pb = InstrumentedProgress(to_file=StringIO())
131
# instantaneous updates should be squelched
132
pb.update('me', 1, 1)
133
self.assertTrue(pb.always_throttled)
134
pb = InstrumentedProgress(to_file=StringIO())
135
# It's like an instant sleep(1)!
137
# Updates after a second should not be squelched
138
pb.update('me', 1, 1)
139
self.assertFalse(pb.always_throttled)
59
141
def test_clear(self):
60
# <https://bugs.launchpad.net/bzr/+bug/611127> clear must actually
61
# send spaces to clear the line
62
out, view = self.make_view()
63
task = self.make_task(None, view, 'reticulating splines', 5, 20)
64
view.show_progress(task)
66
'\r/ reticulating splines 5/20 \r'
70
'\r/ reticulating splines 5/20 \r'
71
+ '\r' + 79 * ' ' + '\r',
74
def test_render_progress_no_bar(self):
75
"""The default view now has a spinner but no bar."""
76
out, view = self.make_view()
77
# view.enable_bar = False
78
task = self.make_task(None, view, 'reticulating splines', 5, 20)
79
view.show_progress(task)
81
'\r/ reticulating splines 5/20 \r'
84
def test_render_progress_easy(self):
85
"""Just one task and one quarter done"""
86
out, view = self.make_view()
87
view.enable_bar = True
88
task = self.make_task(None, view, 'reticulating splines', 5, 20)
89
view.show_progress(task)
91
'\r[####/ ] reticulating splines 5/20 \r'
94
def test_render_progress_nested(self):
95
"""Tasks proportionally contribute to overall progress"""
96
out, view = self.make_view()
97
task = self.make_task(None, view, 'reticulating splines', 0, 2)
98
task2 = self.make_task(task, view, 'stage2', 1, 2)
99
view.show_progress(task2)
100
view.enable_bar = True
101
# so we're in the first half of the main task, and half way through
104
'[####- ] reticulating splines:stage2 1/2 '
105
, view._render_line())
106
# if the nested task is complete, then we're all the way through the
107
# first half of the overall work
108
task2.update('stage2', 2, 2)
110
'[#########\ ] reticulating splines:stage2 2/2 '
111
, view._render_line())
113
def test_render_progress_sub_nested(self):
114
"""Intermediate tasks don't mess up calculation."""
115
out, view = self.make_view()
116
view.enable_bar = True
117
task_a = ProgressTask(None, progress_view=view)
118
task_a.update('a', 0, 2)
119
task_b = ProgressTask(task_a, progress_view=view)
121
task_c = ProgressTask(task_b, progress_view=view)
122
task_c.update('c', 1, 2)
123
# the top-level task is in its first half; the middle one has no
124
# progress indication, just a label; and the bottom one is half done,
125
# so the overall fraction is 1/4
127
'[####| ] a:b:c 1/2 '
128
, view._render_line())
130
def test_render_truncated(self):
131
# when the bar is too long for the terminal, we prefer not to truncate
132
# the counters because they might be interesting, and because
133
# truncating the numbers might be misleading
134
out, view = self.make_view()
135
task_a = ProgressTask(None, progress_view=view)
136
task_a.update('start_' + 'a' * 200 + '_end', 2000, 5000)
137
line = view._render_line()
139
'- start_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.. 2000/5000',
141
self.assertEqual(len(line), 79)
144
def test_render_with_activity(self):
145
# if the progress view has activity, it's shown before the spinner
146
out, view = self.make_view()
147
task_a = ProgressTask(None, progress_view=view)
148
view._last_transport_msg = ' 123kB 100kB/s '
149
line = view._render_line()
153
self.assertEqual(len(line), 79)
155
task_a.update('start_' + 'a' * 200 + '_end', 2000, 5000)
156
view._last_transport_msg = ' 123kB 100kB/s '
157
line = view._render_line()
159
' 123kB 100kB/s \\ start_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.. 2000/5000',
161
self.assertEqual(len(line), 79)
163
def test_render_progress_unicode_enc_utf8(self):
164
out = tests.StringIOWrapper()
165
out.encoding = "utf-8"
166
view = self.make_view_only(out, 20)
167
task = self.make_task(None, view, u"\xa7", 0, 1)
168
view.show_progress(task)
169
self.assertEqual('\r/ \xc2\xa7 0/1 \r',
172
def test_render_progress_unicode_enc_missing(self):
174
self.assertRaises(AttributeError, getattr, out, "encoding")
175
view = self.make_view_only(out, 20)
176
task = self.make_task(None, view, u"\xa7", 0, 1)
177
view.show_progress(task)
178
self.assertEqual('\r/ ? 0/1 \r',
181
def test_render_progress_unicode_enc_none(self):
182
out = tests.StringIOWrapper()
184
view = self.make_view_only(out, 20)
185
task = self.make_task(None, view, u"\xa7", 0, 1)
186
view.show_progress(task)
187
self.assertEqual('\r/ ? 0/1 \r',
143
pb = TTYProgressBar(to_file=sio, show_eta=False)
144
pb.width = 20 # Just make it easier to test
145
# This should not output anything
147
# These two should not be displayed because
149
pb.update('foo', 1, 3)
150
pb.update('bar', 2, 3)
151
# So pb.clear() has nothing to do
154
# Make sure the next update isn't throttled
156
pb.update('baz', 3, 3)
159
self.assertEqual('\r[=========] baz 3/3'
163
def test_no_eta(self):
164
# An old version of the progress bar would
165
# store every update if show_eta was false
166
# because the eta routine was where it was
168
pb = InstrumentedProgress(to_file=StringIO(), show_eta=False)
169
# Just make sure this first few are throttled
172
# These messages are throttled, and don't contribute
173
for count in xrange(100):
174
pb.update('x', count, 300)
175
self.assertEqual(0, len(pb.last_updates))
180
# These happen too fast, so only one gets through
181
for count in xrange(100):
182
pb.update('x', count+100, 200)
183
self.assertEqual(1, len(pb.last_updates))
187
# But all of these go through, don't let the
188
# last_update list grow without bound
189
for count in xrange(100):
190
pb.update('x', count+100, 200)
192
self.assertEqual(pb._max_last_updates, len(pb.last_updates))
195
class TestProgressTypes(TestCase):
196
"""Test that the right ProgressBar gets instantiated at the right time."""
198
def get_nested(self, outf, term, env_progress=None):
199
"""Setup so that ProgressBar thinks we are in the supplied terminal."""
200
orig_term = os.environ.get('TERM')
201
orig_progress = os.environ.get('BZR_PROGRESS_BAR')
202
os.environ['TERM'] = term
203
if env_progress is not None:
204
os.environ['BZR_PROGRESS_BAR'] = env_progress
205
elif orig_progress is not None:
206
del os.environ['BZR_PROGRESS_BAR']
209
if orig_term is None:
210
del os.environ['TERM']
212
os.environ['TERM'] = orig_term
213
# We may have never created BZR_PROGRESS_BAR
214
# So we can't just delete like we can 'TERM' (which is always set)
215
if orig_progress is None:
216
if 'BZR_PROGRESS_BAR' in os.environ:
217
del os.environ['BZR_PROGRESS_BAR']
219
os.environ['BZR_PROGRESS_BAR'] = orig_progress
221
self.addCleanup(reset)
223
stack = ProgressBarStack(to_file=outf)
224
pb = stack.get_nested()
225
pb.start_time -= 1 # Make sure it is ready to write
226
pb.width = 20 # And it is of reasonable size
229
def test_tty_progress(self):
230
# Make sure the ProgressBarStack thinks it is
231
# writing out to a terminal, and thus uses a TTYProgressBar
233
pb = self.get_nested(out, 'xterm')
234
self.assertIsInstance(pb, TTYProgressBar)
236
pb.update('foo', 1, 2)
237
pb.update('bar', 2, 2)
241
self.assertEqual('\r/ [==== ] foo 1/2'
242
'\r- [=======] bar 2/2'
246
def test_dots_progress(self):
247
# Make sure the ProgressBarStack thinks it is
248
# not writing out to a terminal, and thus uses a
250
out = _NonTTYStringIO()
251
pb = self.get_nested(out, 'xterm')
252
self.assertIsInstance(pb, DotsProgressBar)
254
pb.update('foo', 1, 2)
255
pb.update('bar', 2, 2)
259
self.assertEqual('foo: .'
264
def test_no_isatty_progress(self):
265
# Make sure ProgressBarStack handles a plain StringIO()
267
out = cStringIO.StringIO()
268
pb = self.get_nested(out, 'xterm')
270
self.assertIsInstance(pb, DotsProgressBar)
272
def test_dumb_progress(self):
273
# Make sure the ProgressBarStack thinks it is writing out to a
274
# terminal, but it is the emacs 'dumb' terminal, so it uses
277
pb = self.get_nested(out, 'dumb')
279
self.assertIsInstance(pb, DotsProgressBar)
281
def test_progress_env_tty(self):
282
# The environ variable BZR_PROGRESS_BAR controls what type of
283
# progress bar we will get, even if it wouldn't usually be that type
286
# Usually, this would be a DotsProgressBar
287
out = cStringIO.StringIO()
288
pb = self.get_nested(out, 'dumb', 'tty')
290
# Even though we are not a tty, the env_var will override
291
self.assertIsInstance(pb, TTYProgressBar)
293
def test_progress_env_dots(self):
294
# Even though we are in a tty, the env_var will override
296
pb = self.get_nested(out, 'xterm', 'dots')
298
self.assertIsInstance(pb, DotsProgressBar)
300
def test_progress_env_none(self):
301
# Even though we are in a valid tty, no progress
303
pb = self.get_nested(out, 'xterm', 'none')
305
self.assertIsInstance(pb, DummyProgress)
307
def test_progress_env_invalid(self):
309
self.assertRaises(errors.InvalidProgressBarType, self.get_nested,
310
out, 'xterm', 'nonexistant')
added
removed
bzrlib/tests/test_progress.py
