/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_progress.py

  • Committer: Robert Collins
  • Date: 2007-07-15 15:40:37 UTC
  • mto: (2592.3.33 repository)
  • mto: This revision was merged to the branch mainline in revision 2624.
  • Revision ID: robertc@robertcollins.net-20070715154037-3ar8g89decddc9su
Make GraphIndex accept nodes as key, value, references, so that the method
signature is closer to what a simple key->value index delivers. Also
change the behaviour when the reference list count is zero to accept
key, value as nodes, and emit key, value to make it identical in that case
to a simple key->value index. This may not be a good idea, but for now it
seems ok.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_progress.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
16
 
18
17
import os
19
18
from StringIO import StringIO
20
19
 
21
20
from bzrlib import errors
22
21
from bzrlib.progress import (
23
 
    ProgressTask,
24
 
    )
25
 
from bzrlib.symbol_versioning import (
26
 
    deprecated_in,
27
 
    )
 
22
        DummyProgress,
 
23
        ChildProgress,
 
24
        TTYProgressBar,
 
25
        DotsProgressBar,
 
26
        ProgressBarStack,
 
27
        )
28
28
from bzrlib.tests import TestCase
29
 
from bzrlib.ui.text import (
30
 
    TextProgressView,
31
 
    )
32
 
 
 
29
 
 
30
 
 
31
class FakeStack:
 
32
    def __init__(self, top):
 
33
        self.__top = top
 
34
 
 
35
    def top(self):
 
36
        return self.__top
 
37
 
 
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
        
33
50
 
34
51
class _TTYStringIO(StringIO):
35
52
    """A helper class which makes a StringIO look like a terminal"""
45
62
        return False
46
63
 
47
64
 
48
 
class TestTextProgressView(TestCase):
49
 
    """Tests for text display of progress bars.
50
 
 
51
 
    These try to exercise the progressview independently of its construction,
52
 
    which is arranged by the TextUIFactory.
53
 
    """
54
 
    # The ProgressTask now connects directly to the ProgressView, so we can
55
 
    # check them independently of the factory or of the determination of what
56
 
    # view to use.
57
 
    
58
 
    def make_view(self):
59
 
        out = StringIO()
60
 
        view = TextProgressView(out)
61
 
        view._width = 80
62
 
        return out, view
63
 
    
64
 
    def make_task(self, parent_task, view, msg, curr, total):
65
 
        # would normally be done by UIFactory; is done here so that we don't
66
 
        # have to have one.
67
 
        task = ProgressTask(parent_task, progress_view=view)
68
 
        task.msg = msg
69
 
        task.current_cnt = curr
70
 
        task.total_cnt = total
71
 
        return task
72
 
 
73
 
    def test_render_progress_no_bar(self):
74
 
        """The default view now has a spinner but no bar."""
75
 
        out, view = self.make_view()
76
 
        # view.enable_bar = False
77
 
        task = self.make_task(None, view, 'reticulating splines', 5, 20)
78
 
        view.show_progress(task)
79
 
        self.assertEqual(
80
 
'\r/ reticulating splines 5/20                                                    \r'
81
 
            , out.getvalue())
82
 
 
83
 
    def test_render_progress_easy(self):
84
 
        """Just one task and one quarter done"""
85
 
        out, view = self.make_view()
86
 
        view.enable_bar = True
87
 
        task = self.make_task(None, view, 'reticulating splines', 5, 20)
88
 
        view.show_progress(task)
89
 
        self.assertEqual(
90
 
'\r[####/               ] reticulating splines 5/20                               \r'
91
 
            , out.getvalue())
92
 
 
93
 
    def test_render_progress_nested(self):
94
 
        """Tasks proportionally contribute to overall progress"""
95
 
        out, view = self.make_view()
96
 
        task = self.make_task(None, view, 'reticulating splines', 0, 2)
97
 
        task2 = self.make_task(task, view, 'stage2', 1, 2)
98
 
        view.show_progress(task2)
99
 
        view.enable_bar = True
100
 
        # so we're in the first half of the main task, and half way through
101
 
        # that
102
 
        self.assertEqual(
103
 
r'[####-               ] reticulating splines:stage2 1/2'
104
 
            , view._render_line())
105
 
        # if the nested task is complete, then we're all the way through the
106
 
        # first half of the overall work
107
 
        task2.update('stage2', 2, 2)
108
 
        self.assertEqual(
109
 
r'[#########\          ] reticulating splines:stage2 2/2'
110
 
            , view._render_line())
111
 
 
112
 
    def test_render_progress_sub_nested(self):
113
 
        """Intermediate tasks don't mess up calculation."""
114
 
        out, view = self.make_view()
115
 
        view.enable_bar = True
116
 
        task_a = ProgressTask(None, progress_view=view)
117
 
        task_a.update('a', 0, 2)
118
 
        task_b = ProgressTask(task_a, progress_view=view)
119
 
        task_b.update('b')
120
 
        task_c = ProgressTask(task_b, progress_view=view)
121
 
        task_c.update('c', 1, 2)
122
 
        # the top-level task is in its first half; the middle one has no
123
 
        # progress indication, just a label; and the bottom one is half done,
124
 
        # so the overall fraction is 1/4
125
 
        self.assertEqual(
126
 
            r'[####|               ] a:b:c 1/2'
127
 
            , view._render_line())
 
65
class TestProgress(TestCase):
 
66
    def setUp(self):
 
67
        q = DummyProgress()
 
68
        self.top = ChildProgress(_stack=FakeStack(q))
 
69
 
 
70
    def test_propogation(self):
 
71
        self.top.update('foobles', 1, 2)
 
72
        self.assertEqual(self.top.message, 'foobles')
 
73
        self.assertEqual(self.top.current, 1)
 
74
        self.assertEqual(self.top.total, 2)
 
75
        self.assertEqual(self.top.child_fraction, 0)
 
76
        child = ChildProgress(_stack=FakeStack(self.top))
 
77
        child.update('baubles', 2, 4)
 
78
        self.assertEqual(self.top.message, 'foobles')
 
79
        self.assertEqual(self.top.current, 1)
 
80
        self.assertEqual(self.top.total, 2)
 
81
        self.assertEqual(self.top.child_fraction, 0.5)
 
82
        grandchild = ChildProgress(_stack=FakeStack(child))
 
83
        grandchild.update('barbells', 1, 2)
 
84
        self.assertEqual(self.top.child_fraction, 0.625)
 
85
        self.assertEqual(child.child_fraction, 0.5)
 
86
        child.update('baubles', 3, 4)
 
87
        self.assertEqual(child.child_fraction, 0)
 
88
        self.assertEqual(self.top.child_fraction, 0.75)
 
89
        grandchild.update('barbells', 1, 2)
 
90
        self.assertEqual(self.top.child_fraction, 0.875)
 
91
        grandchild.update('barbells', 2, 2)
 
92
        self.assertEqual(self.top.child_fraction, 1)
 
93
        child.update('baubles', 4, 4)
 
94
        self.assertEqual(self.top.child_fraction, 1)
 
95
        #test clamping
 
96
        grandchild.update('barbells', 2, 2)
 
97
        self.assertEqual(self.top.child_fraction, 1)
 
98
 
 
99
    def test_implementations(self):
 
100
        for implementation in (TTYProgressBar, DotsProgressBar, 
 
101
                               DummyProgress):
 
102
            self.check_parent_handling(implementation)
 
103
 
 
104
    def check_parent_handling(self, parentclass):
 
105
        top = parentclass(to_file=StringIO())
 
106
        top.update('foobles', 1, 2)
 
107
        child = ChildProgress(_stack=FakeStack(top))
 
108
        child.update('baubles', 4, 4)
 
109
        top.update('lala', 2, 2)
 
110
        child.update('baubles', 4, 4)
 
111
 
 
112
    def test_stacking(self):
 
113
        self.check_stack(TTYProgressBar, ChildProgress)
 
114
        self.check_stack(DotsProgressBar, ChildProgress)
 
115
        self.check_stack(DummyProgress, DummyProgress)
 
116
 
 
117
    def check_stack(self, parent_class, child_class):
 
118
        stack = ProgressBarStack(klass=parent_class, to_file=StringIO())
 
119
        parent = stack.get_nested()
 
120
        try:
 
121
            self.assertIs(parent.__class__, parent_class)
 
122
            child = stack.get_nested()
 
123
            try:
 
124
                self.assertIs(child.__class__, child_class)
 
125
            finally:
 
126
                child.finished()
 
127
        finally:
 
128
            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')