← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_progress.py

  • Committer: Martin Pool
  • Date: 2006-03-21 12:26:54 UTC
  • mto: This revision was merged to the branch mainline in revision 1621.
  • Revision ID: mbp@sourcefrog.net-20060321122654-514047ed65795a17
New developer commands 'weave-list' and 'weave-join'.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_progress.py
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2006 by 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
import os
18
17
from StringIO import StringIO
19
18
 
20
 
from bzrlib import errors
21
 
from bzrlib.progress import (
22
 
        DummyProgress,
23
 
        ChildProgress,
24
 
        TTYProgressBar,
25
 
        DotsProgressBar,
26
 
        ProgressBarStack,
27
 
        )
 
19
from bzrlib.progress import *
28
20
from bzrlib.tests import TestCase
29
21
 
30
 
 
31
22
class FakeStack:
32
23
    def __init__(self, top):
33
24
        self.__top = top
35
26
    def top(self):
36
27
        return self.__top
37
28
 
38
 
class InstrumentedProgress(TTYProgressBar):
39
 
    """TTYProgress variant that tracks outcomes"""
40
 
 
41
 
    def __init__(self, *args, **kwargs):
42
 
        self.always_throttled = True
43
 
        TTYProgressBar.__init__(self, *args, **kwargs)
44
 
 
45
 
    def throttle(self, old_message):
46
 
        result = TTYProgressBar.throttle(self, old_message)
47
 
        if result is False:
48
 
            self.always_throttled = False
49
 
        
50
 
 
51
 
class _TTYStringIO(StringIO):
52
 
    """A helper class which makes a StringIO look like a terminal"""
53
 
 
54
 
    def isatty(self):
55
 
        return True
56
 
 
57
 
 
58
 
class _NonTTYStringIO(StringIO):
59
 
    """Helper that implements isatty() but returns False"""
60
 
 
61
 
    def isatty(self):
62
 
        return False
63
 
 
64
 
 
65
29
class TestProgress(TestCase):
66
30
    def setUp(self):
67
31
        q = DummyProgress()
126
90
                child.finished()
127
91
        finally:
128
92
            parent.finished()
129
 
 
130
 
    def test_throttling(self):
131
 
        pb = InstrumentedProgress(to_file=StringIO())
132
 
        # instantaneous updates should be squelched
133
 
        pb.update('me', 1, 1)
134
 
        self.assertTrue(pb.always_throttled)
135
 
        pb = InstrumentedProgress(to_file=StringIO())
136
 
        # It's like an instant sleep(1)!
137
 
        pb.start_time -= 1
138
 
        # Updates after a second should not be squelched
139
 
        pb.update('me', 1, 1)
140
 
        self.assertFalse(pb.always_throttled)
141
 
 
142
 
    def test_clear(self):
143
 
        sio = StringIO()
144
 
        pb = TTYProgressBar(to_file=sio, show_eta=False)
145
 
        pb.width = 20 # Just make it easier to test
146
 
        # This should not output anything
147
 
        pb.clear()
148
 
        # These two should not be displayed because
149
 
        # of throttling
150
 
        pb.update('foo', 1, 3)
151
 
        pb.update('bar', 2, 3)
152
 
        # So pb.clear() has nothing to do
153
 
        pb.clear()
154
 
 
155
 
        # Make sure the next update isn't throttled
156
 
        pb.start_time -= 1
157
 
        pb.update('baz', 3, 3)
158
 
        pb.clear()
159
 
 
160
 
        self.assertEqual('\r[=========] baz 3/3'
161
 
                         '\r                   \r',
162
 
                         sio.getvalue())
163
 
 
164
 
    def test_no_eta(self):
165
 
        # An old version of the progress bar would
166
 
        # store every update if show_eta was false
167
 
        # because the eta routine was where it was
168
 
        # cleaned out
169
 
        pb = InstrumentedProgress(to_file=StringIO(), show_eta=False)
170
 
        # Just make sure this first few are throttled
171
 
        pb.start_time += 5
172
 
 
173
 
        # These messages are throttled, and don't contribute
174
 
        for count in xrange(100):
175
 
            pb.update('x', count, 300)
176
 
        self.assertEqual(0, len(pb.last_updates))
177
 
 
178
 
        # Unthrottle by time
179
 
        pb.start_time -= 10
180
 
 
181
 
        # These happen too fast, so only one gets through
182
 
        for count in xrange(100):
183
 
            pb.update('x', count+100, 200)
184
 
        self.assertEqual(1, len(pb.last_updates))
185
 
 
186
 
        pb.MIN_PAUSE = 0.0
187
 
 
188
 
        # But all of these go through, don't let the
189
 
        # last_update list grow without bound
190
 
        for count in xrange(100):
191
 
            pb.update('x', count+100, 200)
192
 
 
193
 
        self.assertEqual(pb._max_last_updates, len(pb.last_updates))
194
 
 
195
 
 
196
 
class TestProgressTypes(TestCase):
197
 
    """Test that the right ProgressBar gets instantiated at the right time."""
198
 
 
199
 
    def get_nested(self, outf, term, env_progress=None):
200
 
        """Setup so that ProgressBar thinks we are in the supplied terminal."""
201
 
        orig_term = os.environ.get('TERM')
202
 
        orig_progress = os.environ.get('BZR_PROGRESS_BAR')
203
 
        os.environ['TERM'] = term
204
 
        if env_progress is not None:
205
 
            os.environ['BZR_PROGRESS_BAR'] = env_progress
206
 
        elif orig_progress is not None:
207
 
            del os.environ['BZR_PROGRESS_BAR']
208
 
 
209
 
        def reset():
210
 
            if orig_term is None:
211
 
                del os.environ['TERM']
212
 
            else:
213
 
                os.environ['TERM'] = orig_term
214
 
            # We may have never created BZR_PROGRESS_BAR
215
 
            # So we can't just delete like we can 'TERM' (which is always set)
216
 
            if orig_progress is None:
217
 
                if 'BZR_PROGRESS_BAR' in os.environ:
218
 
                    del os.environ['BZR_PROGRESS_BAR']
219
 
            else:
220
 
                os.environ['BZR_PROGRESS_BAR'] = orig_progress
221
 
 
222
 
        self.addCleanup(reset)
223
 
 
224
 
        stack = ProgressBarStack(to_file=outf)
225
 
        pb = stack.get_nested()
226
 
        pb.start_time -= 1 # Make sure it is ready to write
227
 
        pb.width = 20 # And it is of reasonable size
228
 
        return pb
229
 
 
230
 
    def test_tty_progress(self):
231
 
        # Make sure the ProgressBarStack thinks it is
232
 
        # writing out to a terminal, and thus uses a TTYProgressBar
233
 
        out = _TTYStringIO()
234
 
        pb = self.get_nested(out, 'xterm')
235
 
        self.assertIsInstance(pb, TTYProgressBar)
236
 
        try:
237
 
            pb.update('foo', 1, 2)
238
 
            pb.update('bar', 2, 2)
239
 
        finally:
240
 
            pb.finished()
241
 
 
242
 
        self.assertEqual('\r/ [====   ] foo 1/2'
243
 
                         '\r- [=======] bar 2/2'
244
 
                         '\r                   \r',
245
 
                         out.getvalue())
246
 
 
247
 
    def test_noninteractive_progress(self):
248
 
        out = _NonTTYStringIO()
249
 
        pb = self.get_nested(out, 'xterm')
250
 
        self.assertIsInstance(pb, DummyProgress)
251
 
        try:
252
 
            pb.update('foo', 1, 2)
253
 
            pb.update('bar', 2, 2)
254
 
        finally:
255
 
            pb.finished()
256
 
        self.assertEqual('', out.getvalue())
257
 
 
258
 
    def test_dots_progress(self):
259
 
        # make sure we get the right progress bar when not on a terminal
260
 
        out = _NonTTYStringIO()
261
 
        pb = self.get_nested(out, 'xterm', 'dots')
262
 
        self.assertIsInstance(pb, DotsProgressBar)
263
 
        try:
264
 
            pb.update('foo', 1, 2)
265
 
            pb.update('bar', 2, 2)
266
 
        finally:
267
 
            pb.finished()
268
 
        self.assertEqual('foo: .'
269
 
                         '\nbar: .'
270
 
                         '\n',
271
 
                         out.getvalue())
272
 
 
273
 
    def test_no_isatty_progress(self):
274
 
        # Make sure ProgressBarStack handles a plain StringIO()
275
 
        import cStringIO
276
 
        out = cStringIO.StringIO()
277
 
        pb = self.get_nested(out, 'xterm')
278
 
        pb.finished()
279
 
        self.assertIsInstance(pb, DummyProgress)
280
 
 
281
 
    def test_dumb_progress(self):
282
 
        # using a terminal that can't do cursor movement
283
 
        out = _TTYStringIO()
284
 
        pb = self.get_nested(out, 'dumb')
285
 
        pb.finished()
286
 
        self.assertIsInstance(pb, DummyProgress)
287
 
 
288
 
    def test_progress_env_tty(self):
289
 
        # The environ variable BZR_PROGRESS_BAR controls what type of
290
 
        # progress bar we will get, even if it wouldn't usually be that type
291
 
        import cStringIO
292
 
 
293
 
        # Usually, this would be a DotsProgressBar
294
 
        out = cStringIO.StringIO()
295
 
        pb = self.get_nested(out, 'dumb', 'tty')
296
 
        pb.finished()
297
 
        # Even though we are not a tty, the env_var will override
298
 
        self.assertIsInstance(pb, TTYProgressBar)
299
 
 
300
 
    def test_progress_env_none(self):
301
 
        # Even though we are in a valid tty, no progress
302
 
        out = _TTYStringIO()
303
 
        pb = self.get_nested(out, 'xterm', 'none')
304
 
        pb.finished()
305
 
        self.assertIsInstance(pb, DummyProgress)
306
 
 
307
 
    def test_progress_env_invalid(self):
308
 
        out = _TTYStringIO()
309
 
        self.assertRaises(errors.InvalidProgressBarType, self.get_nested,
310
 
            out, 'xterm', 'nonexistant')